isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-26 18:11:05 -05:00
Code Issues Packages Projects Releases Wiki Activity
abbd28f484
mutter/cogl/cogl-primitive.c

580 lines
19 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 07:54:07 -04: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
#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 14:31:53 -05: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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-02 20:02:12 -05: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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 13:57:33 -04: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 07:54:07 -04: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-19 20:24:16 -04: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-02 20:02:12 -05: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 07:54:07 -04: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 14:31:53 -05: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 07:54:07 -04:00
cogl_object_ref (attribute);
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 14:31:53 -05:00
g_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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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 12:13:01 -04: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-02 20:02:12 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 12:13:01 -04: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 11:34:48 -04: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 12:13:01 -04: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 07:54:07 -04: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 14:31:53 -05: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 07:54:07 -04: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 14:31:53 -05: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 07:54:07 -04: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 14:31:53 -05: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 07:54:07 -04: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 11:34:48 -04: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 07:54:07 -04: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 14:31:53 -05: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 07:54:07 -04: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-02 20:02:12 -05: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 11:34:48 -04: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 07:54:07 -04: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 12:42:11 -04:00
CoglPrimitive *
cogl_primitive_new_p2 (CoglVerticesMode mode,
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 07:29:49 -05: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 12:42:11 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:42:11 -04: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 10:01:41 -05: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 12:42:11 -04: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-02 20:02:12 -05: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 12:42:11 -04: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 10:48:31 -04:00
CoglPrimitive *
cogl_primitive_new_p3 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p2c4 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p3c4 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p2t2 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p3t2 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:48:31 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p2t2c4 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04:00
}
CoglPrimitive *
cogl_primitive_new_p3t2c4 (CoglVerticesMode mode,
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 07:29:49 -05: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 10:48:31 -04: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 10:01:41 -05:00
CoglAttributeBuffer *attribute_buffer =
cogl_attribute_buffer_new (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-02 20:02:12 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 10:01:41 -05: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 14:31:53 -05: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 12:13:01 -04: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 10:01:41 -05: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 12:13:01 -04: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-02 20:02:12 -05: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 10:48:31 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04: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 13:57:33 -04:00
static void
warn_about_midscene_changes (void)
{
static gboolean seen = FALSE;
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-19 20:24:16 -04: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 13:57:33 -04: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 07:54:07 -04: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-02 20:02:12 -05: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 07:54:07 -04:00
{
int 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 13:57:33 -04:00
g_return_if_fail (cogl_is_primitive (primitive));
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-19 20:24:16 -04: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-02 20:02:12 -05: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 07:54:07 -04: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 14:31:53 -05:00
g_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-19 20:24:16 -04: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 07:54:07 -04: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-19 20:24:16 -04: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 07:54:07 -04:00
}
int
cogl_primitive_get_first_vertex (CoglPrimitive *primitive)
{
g_return_val_if_fail (cogl_is_primitive (primitive), 0);
return primitive->first_vertex;
}
void
cogl_primitive_set_first_vertex (CoglPrimitive *primitive,
int first_vertex)
{
g_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 13:57:33 -04: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 07:54:07 -04:00
primitive->first_vertex = first_vertex;
}
int
cogl_primitive_get_n_vertices (CoglPrimitive *primitive)
{
g_return_val_if_fail (cogl_is_primitive (primitive), 0);
return primitive->n_vertices;
}
void
cogl_primitive_set_n_vertices (CoglPrimitive *primitive,
int n_vertices)
{
g_return_if_fail (cogl_is_primitive (primitive));
primitive->n_vertices = n_vertices;
}
CoglVerticesMode
cogl_primitive_get_mode (CoglPrimitive *primitive)
{
g_return_val_if_fail (cogl_is_primitive (primitive), 0);
return primitive->mode;
}
void
cogl_primitive_set_mode (CoglPrimitive *primitive,
CoglVerticesMode mode)
{
g_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 13:57:33 -04: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 07:54:07 -04:00
primitive->mode = mode;
}
void
cogl_primitive_set_indices (CoglPrimitive *primitive,
CoglIndices *indices)
{
g_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 13:57:33 -04: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 07:54:07 -04:00
if (indices)
cogl_object_ref (indices);
if (primitive->indices)
cogl_object_unref (primitive->indices);
primitive->indices = indices;
}
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 13:57:33 -04:00
CoglPrimitive *
_cogl_primitive_immutable_ref (CoglPrimitive *primitive)
{
int i;
g_return_val_if_fail (cogl_is_primitive (primitive), NULL);
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-19 20:24:16 -04: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 13:57:33 -04:00
return primitive;
}
void
_cogl_primitive_immutable_unref (CoglPrimitive *primitive)
{
int i;
g_return_if_fail (cogl_is_primitive (primitive));
g_return_if_fail (primitive->immutable_ref > 0);
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-19 20:24:16 -04: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 13:57:33 -04: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 07:54:07 -04:00
void
primitive: Adds _cogl_primitive_draw api taking flags This adds an internal _cogl_primitive_draw API that takes CoglDrawFlags like _cogl_draw_attributes does which allows us to draw a primitive but skip things like flushing journals, flushing framebuffer state and avoid validating the current pipeline. This allows us to draw primitives in places that could otherwise cause recursion. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 13:45:16 -04:00
_cogl_primitive_draw (CoglPrimitive *primitive,
CoglDrawFlags flags)
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 07:54:07 -04:00
{
if (primitive->indices)
primitive: Adds _cogl_primitive_draw api taking flags This adds an internal _cogl_primitive_draw API that takes CoglDrawFlags like _cogl_draw_attributes does which allows us to draw a primitive but skip things like flushing journals, flushing framebuffer state and avoid validating the current pipeline. This allows us to draw primitives in places that could otherwise cause recursion. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 13:45:16 -04:00
_cogl_draw_indexed_attributes (primitive->mode,
primitive->first_vertex,
primitive->n_vertices,
primitive->indices,
primitive->attributes,
primitive->n_attributes,
flags);
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 07:54:07 -04:00
else
primitive: Adds _cogl_primitive_draw api taking flags This adds an internal _cogl_primitive_draw API that takes CoglDrawFlags like _cogl_draw_attributes does which allows us to draw a primitive but skip things like flushing journals, flushing framebuffer state and avoid validating the current pipeline. This allows us to draw primitives in places that could otherwise cause recursion. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 13:45:16 -04:00
_cogl_draw_attributes (primitive->mode,
primitive->first_vertex,
primitive->n_vertices,
primitive->attributes,
primitive->n_attributes,
flags);
}
/* XXX: cogl_draw_primitive() ? */
void
cogl_primitive_draw (CoglPrimitive *primitive)
{
_cogl_primitive_draw (primitive, 0 /* no flags */);
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 07:54:07 -04:00
}
Reference in New Issue Copy Permalink