brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
446dd70b91
mutter/cogl/cogl-primitive.c

602 lines
20 KiB
C
Raw Normal View History

cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
#include "cogl-util.h"
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
#include "cogl-object-private.h"
#include "cogl-primitive.h"
#include "cogl-primitive-private.h"
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
#include "cogl-attribute-private.h"
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
#include <stdarg.h>
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
#include <string.h>
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
static void _cogl_primitive_free (CoglPrimitive *primitive);
COGL_OBJECT_DEFINE (Primitive, primitive);
CoglPrimitive *
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
cogl_primitive_new_with_attributes (CoglVerticesMode mode,
int n_vertices,
CoglAttribute **attributes,
int n_attributes)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
CoglPrimitive *primitive;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
int i;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
primitive = g_slice_alloc (sizeof (CoglPrimitive) +
sizeof (CoglAttribute *) * (n_attributes - 1));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive->mode = mode;
primitive->first_vertex = 0;
primitive->n_vertices = n_vertices;
primitive->indices = NULL;
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
primitive->immutable_ref = 0;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
primitive->n_attributes = n_attributes;
primitive->n_embedded_attributes = n_attributes;
primitive->attributes = &primitive->embedded_attribute;
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
for (i = 0; i < n_attributes; i++)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
CoglAttribute *attribute = attributes[i];
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
cogl_object_ref (attribute);
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_attribute (attribute), NULL);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
primitive->attributes[i] = attribute;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
return _cogl_primitive_object_new (primitive);
}
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
/* This is just an internal convenience wrapper around
new_with_attributes that also unrefs the attributes. It is just
used for the builtin struct constructors */
static CoglPrimitive *
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
_cogl_primitive_new_with_attributes_unref (CoglVerticesMode mode,
int n_vertices,
CoglAttribute **attributes,
int n_attributes)
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
{
CoglPrimitive *primitive;
int i;
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
primitive = cogl_primitive_new_with_attributes (mode,
n_vertices,
attributes,
n_attributes);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
cogl-primitive: Fix some broken changes for removal of NULL terminator Commit 3c1e83c7 changed uses of arrays of CoglAttributes to take a length instead of being NULL terminated. In cogl_primitive_new it was still adding the NULL terminator to the array it passes to cogl_primitive_new_with_attributes but then it was also including this terminator in the count so it would just segfault when it tries to ref the NULL pointer. Also _cogl_primitive_new_with_attributes_unref was still trying to detect the NULL terminator so it would also crash.
2011-05-16 15:34:48 +00:00
for (i = 0; i < n_attributes; i++)
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
cogl_object_unref (attributes[i]);
return primitive;
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
CoglPrimitive *
cogl_primitive_new (CoglVerticesMode mode,
int n_vertices,
...)
{
va_list ap;
int n_attributes;
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
CoglAttribute **attributes;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
int i;
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
CoglAttribute *attribute;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
va_start (ap, n_vertices);
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
for (n_attributes = 0; va_arg (ap, CoglAttribute *); n_attributes++)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
;
va_end (ap);
cogl-primitive: Fix some broken changes for removal of NULL terminator Commit 3c1e83c7 changed uses of arrays of CoglAttributes to take a length instead of being NULL terminated. In cogl_primitive_new it was still adding the NULL terminator to the array it passes to cogl_primitive_new_with_attributes but then it was also including this terminator in the count so it would just segfault when it tries to ref the NULL pointer. Also _cogl_primitive_new_with_attributes_unref was still trying to detect the NULL terminator so it would also crash.
2011-05-16 15:34:48 +00:00
attributes = g_alloca (sizeof (CoglAttribute *) * n_attributes);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
va_start (ap, n_vertices);
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
for (i = 0; (attribute = va_arg (ap, CoglAttribute *)); i++)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
attributes[i] = attribute;
va_end (ap);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return cogl_primitive_new_with_attributes (mode, n_vertices,
attributes,
cogl-primitive: Fix some broken changes for removal of NULL terminator Commit 3c1e83c7 changed uses of arrays of CoglAttributes to take a length instead of being NULL terminated. In cogl_primitive_new it was still adding the NULL terminator to the array it passes to cogl_primitive_new_with_attributes but then it was also including this terminator in the count so it would just segfault when it tries to ref the NULL pointer. Also _cogl_primitive_new_with_attributes_unref was still trying to detect the NULL terminator so it would also crash.
2011-05-16 15:34:48 +00:00
i);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p2 (CoglContext *ctx,
CoglVerticesMode mode,
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP2 *data)
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[1];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP2),
offsetof (CoglVertexP2, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
1);
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 16:42:11 +00:00
}
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p3 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP3 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[1];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP3),
offsetof (CoglVertexP3, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
1);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP2C4 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[2];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP2C4),
offsetof (CoglVertexP2C4, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_color_in",
sizeof (CoglVertexP2C4),
offsetof (CoglVertexP2C4, r),
4,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
2);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p3c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP3C4 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[2];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP3C4),
offsetof (CoglVertexP3C4, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_color_in",
sizeof (CoglVertexP3C4),
offsetof (CoglVertexP3C4, r),
4,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
2);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p2t2 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP2T2 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2T2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[2];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP2T2),
offsetof (CoglVertexP2T2, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_tex_coord0_in",
sizeof (CoglVertexP2T2),
offsetof (CoglVertexP2T2, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
2);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p3t2 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP3T2 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3T2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[2];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP3T2),
offsetof (CoglVertexP3T2, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_tex_coord0_in",
sizeof (CoglVertexP3T2),
offsetof (CoglVertexP3T2, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
2);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p2t2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP2T2C4 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx,
n_vertices * sizeof (CoglVertexP2T2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[3];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_tex_coord0_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[2] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_color_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, r),
4,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
3);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
CoglPrimitive *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_primitive_new_p3t2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 12:29:49 +00:00
const CoglVertexP3T2C4 *data)
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
{
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
CoglAttributeBuffer *attribute_buffer =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
cogl_attribute_buffer_new (ctx,
n_vertices * sizeof (CoglVertexP3T2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute *attributes[3];
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[0] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_position_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[1] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_tex_coord0_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
attributes[2] = cogl_attribute_new (attribute_buffer,
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 19:31:53 +00:00
"cogl_color_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, r),
4,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
cogl_object_unref (attribute_buffer);
cogl-primitive: Fix the ref-counting for the convenience constuctors The convenience constructors for the builtin vertex structs were creating the primitive and then immediately destroying it and returning the pointer. I think the intention was to unref the attributes instead. This adds an internal wrapper around the new_with_attributes_array constructor which unrefs the attributes instead of the primitive. The convenience constructors now use that.
2010-11-04 16:13:01 +00:00
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
return _cogl_primitive_new_with_attributes_unref (mode, n_vertices,
attributes,
3);
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 14:48:31 +00:00
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
static void
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
_cogl_primitive_free (CoglPrimitive *primitive)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
int i;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
for (i = 0; i < primitive->n_attributes; i++)
cogl_object_unref (primitive->attributes[i]);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
if (primitive->attributes != &primitive->embedded_attribute)
g_slice_free1 (sizeof (CoglAttribute *) * primitive->n_attributes,
primitive->attributes);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: Don't leak indices If a CoglPrimitive is associated with a set of indices then we must unref those indices when freeing the primitive to avoid a leak. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 45cac786b55c953e44f98b864add952b9e398b13)
2012-08-07 14:25:21 +00:00
if (primitive->indices)
cogl_object_unref (primitive->indices);
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
g_slice_free1 (sizeof (CoglPrimitive) +
sizeof (CoglAttribute *) *
(primitive->n_embedded_attributes - 1), primitive);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
static void
warn_about_midscene_changes (void)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool seen = FALSE;
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
if (!seen)
{
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
g_warning ("Mid-scene modification of primitives has "
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
"undefined results\n");
seen = TRUE;
}
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
void
cogl_primitive_set_attributes (CoglPrimitive *primitive,
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
CoglAttribute **attributes,
int n_attributes)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
int i;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
if (G_UNLIKELY (primitive->immutable_ref))
{
warn_about_midscene_changes ();
return;
}
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
/* NB: we don't unref the previous attributes before refing the new
* in case we would end up releasing the last reference for an
* attribute thats actually in the new list too. */
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-03 01:02:12 +00:00
for (i = 0; i < n_attributes; i++)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_attribute (attributes[i]));
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
cogl_object_ref (attributes[i]);
}
for (i = 0; i < primitive->n_attributes; i++)
cogl_object_unref (primitive->attributes[i]);
/* First try to use the embedded storage assocated with the
* primitive, else fallback to slice allocating separate storage for
* the attribute pointers... */
if (n_attributes <= primitive->n_embedded_attributes)
{
if (primitive->attributes != &primitive->embedded_attribute)
g_slice_free1 (sizeof (CoglAttribute *) * primitive->n_attributes,
primitive->attributes);
primitive->attributes = &primitive->embedded_attribute;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
else
{
if (primitive->attributes != &primitive->embedded_attribute)
g_slice_free1 (sizeof (CoglAttribute *) * primitive->n_attributes,
primitive->attributes);
primitive->attributes =
g_slice_alloc (sizeof (CoglAttribute *) * n_attributes);
}
memcpy (primitive->attributes, attributes,
sizeof (CoglAttribute *) * n_attributes);
primitive->n_attributes = n_attributes;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
int
cogl_primitive_get_first_vertex (CoglPrimitive *primitive)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
return primitive->first_vertex;
}
void
cogl_primitive_set_first_vertex (CoglPrimitive *primitive,
int first_vertex)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
if (G_UNLIKELY (primitive->immutable_ref))
{
warn_about_midscene_changes ();
return;
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive->first_vertex = first_vertex;
}
int
cogl_primitive_get_n_vertices (CoglPrimitive *primitive)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
return primitive->n_vertices;
}
void
cogl_primitive_set_n_vertices (CoglPrimitive *primitive,
int n_vertices)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive->n_vertices = n_vertices;
}
CoglVerticesMode
cogl_primitive_get_mode (CoglPrimitive *primitive)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
return primitive->mode;
}
void
cogl_primitive_set_mode (CoglPrimitive *primitive,
CoglVerticesMode mode)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
if (G_UNLIKELY (primitive->immutable_ref))
{
warn_about_midscene_changes ();
return;
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive->mode = mode;
}
void
cogl_primitive_set_indices (CoglPrimitive *primitive,
primitive: Add n_indices arg to _set_indices function When associating indices with a CoglPrimitive you are now forced to specify the number of indices that should be read when drawing. It's easy to forget to call cogl_primitive_set_n_vertices() after associating indices with a primitive (and anyway you can see that someone could be led to believe Cogl can determine that implicitly somewhow) so this should avoid a lot of mistakes with using the API. We'd expect that setting indices and updating the n_vertices property would go hand in hand 99% of the time anyway so this change should be more convenient as well as less error prone. This patch adds some documentation for cogl_primitive_set_indices and cogl_primitive_get/set_n_vertices. It also tries to clarify how the CoglPrimitive:n_vertices property is updated and what that property means in relation to other functions too. https://bugzilla.gnome.org/show_bug.cgi?id=661019 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 21:34:59 +00:00
CoglIndices *indices,
int n_indices)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
if (G_UNLIKELY (primitive->immutable_ref))
{
warn_about_midscene_changes ();
return;
}
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
if (indices)
cogl_object_ref (indices);
if (primitive->indices)
cogl_object_unref (primitive->indices);
primitive->indices = indices;
primitive: Add n_indices arg to _set_indices function When associating indices with a CoglPrimitive you are now forced to specify the number of indices that should be read when drawing. It's easy to forget to call cogl_primitive_set_n_vertices() after associating indices with a primitive (and anyway you can see that someone could be led to believe Cogl can determine that implicitly somewhow) so this should avoid a lot of mistakes with using the API. We'd expect that setting indices and updating the n_vertices property would go hand in hand 99% of the time anyway so this change should be more convenient as well as less error prone. This patch adds some documentation for cogl_primitive_set_indices and cogl_primitive_get/set_n_vertices. It also tries to clarify how the CoglPrimitive:n_vertices property is updated and what that property means in relation to other functions too. https://bugzilla.gnome.org/show_bug.cgi?id=661019 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 21:34:59 +00:00
primitive->n_vertices = n_indices;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 11:54:07 +00:00
}
Add cogl_primitive_get_indices() This adds a public getter for the indices property of CoglPrimitive. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 14:01:24 +00:00
CoglIndices *
cogl_primitive_get_indices (CoglPrimitive *primitive)
{
return primitive->indices;
}
Add cogl_primitive_copy() This adds a public function to make a copy of a primitive. The copy is shallow which means it will share the same attributes and attribute buffers. This could be useful for code that wants to have multiple similar primitives with slightly modified properties. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 12:52:18 +00:00
CoglPrimitive *
cogl_primitive_copy (CoglPrimitive *primitive)
{
CoglPrimitive *copy;
copy = cogl_primitive_new_with_attributes (primitive->mode,
primitive->n_vertices,
primitive->attributes,
primitive->n_attributes);
cogl_primitive_set_indices (copy, primitive->indices, primitive->n_vertices);
cogl_primitive_set_first_vertex (copy, primitive->first_vertex);
return copy;
}
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
CoglPrimitive *
_cogl_primitive_immutable_ref (CoglPrimitive *primitive)
{
int i;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), NULL);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
primitive->immutable_ref++;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
for (i = 0; i < primitive->n_attributes; i++)
_cogl_attribute_immutable_ref (primitive->attributes[i]);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
return primitive;
}
void
_cogl_primitive_immutable_unref (CoglPrimitive *primitive)
{
int i;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 21:34:30 +00:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
_COGL_RETURN_IF_FAIL (primitive->immutable_ref > 0);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
primitive->immutable_ref--;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-20 00:24:16 +00:00
for (i = 0; i < primitive->n_attributes; i++)
_cogl_attribute_immutable_unref (primitive->attributes[i]);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 17:57:33 +00:00
}
Add cogl_primitive_foreach_attribute() This adds a public function to iterate the attributes of a CoglPrimitive. Previously there was no way to query back the attributes but there was methods to query back all of the other properties. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 13:29:35 +00:00
void
cogl_primitive_foreach_attribute (CoglPrimitive *primitive,
CoglPrimitiveAttributeCallback callback,
void *user_data)
{
int i;
for (i = 0; i < primitive->n_attributes; i++)
if (!callback (primitive, primitive->attributes[i], user_data))
break;
}
Reference in New Issue Copy Permalink