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

646 lines
22 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
*
This re-licenses Cogl 1.18 under the MIT license Since the Cogl 1.18 branch is actively maintained in parallel with the master branch; this is a counter part to commit 1b83ef938fc16b which re-licensed the master branch to use the MIT license. This re-licensing is a follow up to the proposal that was sent to the Cogl mailing list: http://lists.freedesktop.org/archives/cogl/2013-December/001465.html Note: there was a copyright assignment policy in place for Clutter (and therefore Cogl which was part of Clutter at the time) until the 11th of June 2010 and so we only checked the details after that point (commit 0bbf50f905) For each file, authors were identified via this Git command: $ git blame -p -C -C -C20 -M -M10 0bbf50f905..HEAD We received blanket approvals for re-licensing all Red Hat and Collabora contributions which reduced how many people needed to be contacted individually: - http://lists.freedesktop.org/archives/cogl/2013-December/001470.html - http://lists.freedesktop.org/archives/cogl/2014-January/001536.html Individual approval requests were sent to all the other identified authors who all confirmed the re-license on the Cogl mailinglist: http://lists.freedesktop.org/archives/cogl/2014-January As well as updating the copyright header in all sources files, the COPYING file has been updated to reflect the license change and also document the other licenses used in Cogl such as the SGI Free Software License B, version 2.0 and the 3-clause BSD license. This patch was not simply cherry-picked from master; but the same methodology was used to check the source files.
2014-02-21 20:28:54 -05:00
* A Low Level GPU Graphics and Utilities API
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
*
* Copyright (C) 2010 Intel Corporation.
*
This re-licenses Cogl 1.18 under the MIT license Since the Cogl 1.18 branch is actively maintained in parallel with the master branch; this is a counter part to commit 1b83ef938fc16b which re-licensed the master branch to use the MIT license. This re-licensing is a follow up to the proposal that was sent to the Cogl mailing list: http://lists.freedesktop.org/archives/cogl/2013-December/001465.html Note: there was a copyright assignment policy in place for Clutter (and therefore Cogl which was part of Clutter at the time) until the 11th of June 2010 and so we only checked the details after that point (commit 0bbf50f905) For each file, authors were identified via this Git command: $ git blame -p -C -C -C20 -M -M10 0bbf50f905..HEAD We received blanket approvals for re-licensing all Red Hat and Collabora contributions which reduced how many people needed to be contacted individually: - http://lists.freedesktop.org/archives/cogl/2013-December/001470.html - http://lists.freedesktop.org/archives/cogl/2014-January/001536.html Individual approval requests were sent to all the other identified authors who all confirmed the re-license on the Cogl mailinglist: http://lists.freedesktop.org/archives/cogl/2014-January As well as updating the copyright header in all sources files, the COPYING file has been updated to reflect the license change and also document the other licenses used in Cogl such as the SGI Free Software License B, version 2.0 and the 3-clause BSD license. This patch was not simply cherry-picked from master; but the same methodology was used to check the source files.
2014-02-21 20:28:54 -05:00
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
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
*
*
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
#include "cogl-util.h"
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
#include "cogl-object-private.h"
#include "cogl-primitive.h"
#include "cogl-primitive-private.h"
cogl: rename CoglVertexAttribute CoglAttribute This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to reduce the verbosity of using the API. Another reason is that CoglVertexArray is going to be renamed CoglAttributeBuffer and we want to help emphasize the relationship between CoglAttributes and CoglAttributeBuffers.
2011-01-20 14:31:53 -05:00
#include "cogl-attribute-private.h"
Add _primitive_draw to replace _framebuffer_draw_primitive When splitting out the CoglPath api we saw that we would be left with inconsistent drawing apis if the drawing apis in core Cogl were lumped into the cogl_framebuffer_ api considering other Cogl sub-libraries or that others will want to create higher level drawing apis outside of Cogl but can't use the same namespace. So that we can aim for a more consistent style this adds a cogl_primitive_draw() api, comparable to cogl_path_fill() or cogl_pango_show_layout() that's intended to replace cogl_framebuffer_draw_primitive() Note: the attribute and rectangle drawing apis are still in the cogl_framebuffer_ namespace and this might potentially change but in these cases there is no single object representing the thing being drawn so it seems a more reasonable they they live in the framebuffer namespace for now. Note: the cogl_framebuffer_draw_primitive() api isn't removed by this patch so it can more conveniently be cherry picked to the 1.16 branch so we can mark it deprecated for a short while. Even though it's marked as experimental api we know that there are people using the api so we'd like to give them a chance to switch to the new api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 418912b93ff81a47f9b38114d05335ab76277c48) Conflicts: cogl-pango/cogl-pango-display-list.c cogl/Makefile.am cogl/cogl-framebuffer.c cogl/cogl-pipeline-layer-state.h cogl/cogl2-path.c cogl/driver/gl/cogl-clip-stack-gl.c
2013-07-09 18:47:29 -04:00
#include "cogl-framebuffer-private.h"
Registers gtypes for all public objects and structs This adds much more comprehensive support for gobject-introspection based bindings by registering all objects as fundamental types that inherit from CoglObject, and all structs as boxed types. Co-Author: Robert Bragg <robert@linux.intel.com> Reviewed-by: Neil Roberts <neil@linux.intel.com>
2013-09-02 11:02:42 -04:00
#include "cogl-gtype-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);
Registers gtypes for all public objects and structs This adds much more comprehensive support for gobject-introspection based bindings by registering all objects as fundamental types that inherit from CoglObject, and all structs as boxed types. Co-Author: Robert Bragg <robert@linux.intel.com> Reviewed-by: Neil Roberts <neil@linux.intel.com>
2013-09-02 11:02:42 -04:00
COGL_GTYPE_DEFINE_CLASS (Primitive, primitive);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
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);
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_attribute (attribute), NULL);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p2 (CoglContext *ctx,
CoglVerticesMode mode,
cogl-primitive: Add the missing cogl_primitive_new_p2 function There was a struct defined for CoglP2Vertex but there was no constructor function to use it.
2010-11-04 12:42:11 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p3 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p3c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p2t2 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP2T2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p3t2 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx, n_vertices * sizeof (CoglVertexP3T2), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p2t2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx,
n_vertices * sizeof (CoglVertexP2T2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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 *
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_primitive_new_p3t2c4 (CoglContext *ctx,
CoglVerticesMode mode,
primitive: Adds convenience constructors This adds convenience primitive constructors named like: cogl_primitive_new_p3 or cogl_primitive_new_p3c4 or cogl_primitive_new_p3t2c4 where the letters correspond to the interleved vertex attributes layouts such as CoglP3Vertex which is a struct with 3 float x,y,z members for the [p]osition, or CoglP3T2C4Vertex which is a struct with 3 float x,y,z members for the [p]osition, 2 float s,t members for the [t]exture coordinates and 4 unsigned byte r,g,b,a members for the [c]olor. The hope is that people will find these convenient enough to replace cogl_polygon.
2010-10-12 10:48:31 -04:00
int n_vertices,
cogl: s/Cogl*Vertex/CoglVertex*/ We have a bunch of experimental convenience functions like cogl_primitive_p2/p2t2 that have corresponding vertex structures but it seemed a bit odd to have the vertex annotation e.g. "P2T2" be an infix of the type like CoglP2T2Vertex instead of be a postfix like CoglVertexP2T2. This switches them all to follow the postfix naming style.
2011-01-20 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 =
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 12:08:58 -05:00
cogl_attribute_buffer_new (ctx,
n_vertices * sizeof (CoglVertexP3T2C4), data);
Don't pass around NULL terminated CoglAttribute arrays For the first iteration of the CoglAttribute API several of the new functions accepted a pointer to a NULL terminated list of CoglAttribute pointers - probably as a way to reduce the number of arguments required. This style isn't consistent with existing Cogl APIs though and so we now explicitly pass n_attributes arguments and don't require the NULL termination.
2011-03-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: Don't leak indices If a CoglPrimitive is associated with a set of indices then we must unref those indices when freeing the primitive to avoid a leak. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 45cac786b55c953e44f98b864add952b9e398b13)
2012-08-07 10:25:21 -04:00
if (primitive->indices)
cogl_object_unref (primitive->indices);
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool seen = FALSE;
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 13:57:33 -04:00
if (!seen)
{
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 13:57:33 -04:00
if (G_UNLIKELY (primitive->immutable_ref))
{
warn_about_midscene_changes ();
return;
}
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_attribute (attributes[i]));
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
return primitive->first_vertex;
}
void
cogl_primitive_set_first_vertex (CoglPrimitive *primitive,
int first_vertex)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 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
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)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
return primitive->n_vertices;
}
void
cogl_primitive_set_n_vertices (CoglPrimitive *primitive,
int n_vertices)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
primitive->n_vertices = n_vertices;
}
CoglVerticesMode
cogl_primitive_get_mode (CoglPrimitive *primitive)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), 0);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
return primitive->mode;
}
void
cogl_primitive_set_mode (CoglPrimitive *primitive,
CoglVerticesMode mode)
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 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
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,
primitive: Add n_indices arg to _set_indices function When associating indices with a CoglPrimitive you are now forced to specify the number of indices that should be read when drawing. It's easy to forget to call cogl_primitive_set_n_vertices() after associating indices with a primitive (and anyway you can see that someone could be led to believe Cogl can determine that implicitly somewhow) so this should avoid a lot of mistakes with using the API. We'd expect that setting indices and updating the n_vertices property would go hand in hand 99% of the time anyway so this change should be more convenient as well as less error prone. This patch adds some documentation for cogl_primitive_set_indices and cogl_primitive_get/set_n_vertices. It also tries to clarify how the CoglPrimitive:n_vertices property is updated and what that property means in relation to other functions too. https://bugzilla.gnome.org/show_bug.cgi?id=661019 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 17:34:59 -04:00
CoglIndices *indices,
int n_indices)
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
{
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 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
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: Add n_indices arg to _set_indices function When associating indices with a CoglPrimitive you are now forced to specify the number of indices that should be read when drawing. It's easy to forget to call cogl_primitive_set_n_vertices() after associating indices with a primitive (and anyway you can see that someone could be led to believe Cogl can determine that implicitly somewhow) so this should avoid a lot of mistakes with using the API. We'd expect that setting indices and updating the n_vertices property would go hand in hand 99% of the time anyway so this change should be more convenient as well as less error prone. This patch adds some documentation for cogl_primitive_set_indices and cogl_primitive_get/set_n_vertices. It also tries to clarify how the CoglPrimitive:n_vertices property is updated and what that property means in relation to other functions too. https://bugzilla.gnome.org/show_bug.cgi?id=661019 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 17:34:59 -04:00
primitive->n_vertices = n_indices;
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
}
Add cogl_primitive_get_indices() This adds a public getter for the indices property of CoglPrimitive. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 09:01:24 -05:00
CoglIndices *
cogl_primitive_get_indices (CoglPrimitive *primitive)
{
return primitive->indices;
}
Add cogl_primitive_copy() This adds a public function to make a copy of a primitive. The copy is shallow which means it will share the same attributes and attribute buffers. This could be useful for code that wants to have multiple similar primitives with slightly modified properties. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 07:52:18 -05:00
CoglPrimitive *
cogl_primitive_copy (CoglPrimitive *primitive)
{
CoglPrimitive *copy;
copy = cogl_primitive_new_with_attributes (primitive->mode,
primitive->n_vertices,
primitive->attributes,
primitive->n_attributes);
cogl_primitive_set_indices (copy, primitive->indices, primitive->n_vertices);
cogl_primitive_set_first_vertex (copy, primitive->first_vertex);
return copy;
}
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 13:57:33 -04:00
CoglPrimitive *
_cogl_primitive_immutable_ref (CoglPrimitive *primitive)
{
int i;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_primitive (primitive), NULL);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 13:57:33 -04:00
primitive->immutable_ref++;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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;
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_RETURN_IF_FAIL (cogl_is_primitive (primitive));
_COGL_RETURN_IF_FAIL (primitive->immutable_ref > 0);
primitive: adds immutable ref/unref mechanism This adds a way to mark that a primitive is in use so that modifications will generate a warning. The plan is to use this mechanism when batching primitives in the journal to warn users that mid-scene modifications of primitives is not allowed.
2010-10-26 13:57:33 -04:00
primitive->immutable_ref--;
primitive: micro optimize primitive allocations We've started seeing cases where we want to allocate lots of one-shot primitives per-frame and the cost of allocating primitives becomes important in this case since it can start being noticeable in profiles. The main cost for allocating primitives was the GArray allocation and appending the attributes to the array. This updates the code to simply over allocate the primitive storage so we can embed the list of attributes directly in that allocation. If the user later sets new attributes and there isn't enough embedded space then a separate slice allocation for the new attributes is made but still this should be far less costly than using a GArray as before. Most of the time we would expect when setting new attributes there will still be the same number of attributes, so the embedded space can simple be reused. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-09-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
}
Add cogl_primitive_foreach_attribute() This adds a public function to iterate the attributes of a CoglPrimitive. Previously there was no way to query back the attributes but there was methods to query back all of the other properties. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 08:29:35 -05:00
void
cogl_primitive_foreach_attribute (CoglPrimitive *primitive,
CoglPrimitiveAttributeCallback callback,
void *user_data)
{
int i;
for (i = 0; i < primitive->n_attributes; i++)
if (!callback (primitive, primitive->attributes[i], user_data))
break;
}
Add _primitive_draw to replace _framebuffer_draw_primitive When splitting out the CoglPath api we saw that we would be left with inconsistent drawing apis if the drawing apis in core Cogl were lumped into the cogl_framebuffer_ api considering other Cogl sub-libraries or that others will want to create higher level drawing apis outside of Cogl but can't use the same namespace. So that we can aim for a more consistent style this adds a cogl_primitive_draw() api, comparable to cogl_path_fill() or cogl_pango_show_layout() that's intended to replace cogl_framebuffer_draw_primitive() Note: the attribute and rectangle drawing apis are still in the cogl_framebuffer_ namespace and this might potentially change but in these cases there is no single object representing the thing being drawn so it seems a more reasonable they they live in the framebuffer namespace for now. Note: the cogl_framebuffer_draw_primitive() api isn't removed by this patch so it can more conveniently be cherry picked to the 1.16 branch so we can mark it deprecated for a short while. Even though it's marked as experimental api we know that there are people using the api so we'd like to give them a chance to switch to the new api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 418912b93ff81a47f9b38114d05335ab76277c48) Conflicts: cogl-pango/cogl-pango-display-list.c cogl/Makefile.am cogl/cogl-framebuffer.c cogl/cogl-pipeline-layer-state.h cogl/cogl2-path.c cogl/driver/gl/cogl-clip-stack-gl.c
2013-07-09 18:47:29 -04:00
void
_cogl_primitive_draw (CoglPrimitive *primitive,
CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglDrawFlags flags)
{
if (primitive->indices)
_cogl_framebuffer_draw_indexed_attributes (framebuffer,
pipeline,
primitive->mode,
primitive->first_vertex,
primitive->n_vertices,
primitive->indices,
primitive->attributes,
primitive->n_attributes,
flags);
else
_cogl_framebuffer_draw_attributes (framebuffer,
pipeline,
primitive->mode,
primitive->first_vertex,
primitive->n_vertices,
primitive->attributes,
primitive->n_attributes,
flags);
}
void
cogl_primitive_draw (CoglPrimitive *primitive,
CoglFramebuffer *framebuffer,
CoglPipeline *pipeline)
{
_cogl_primitive_draw (primitive, framebuffer, pipeline, 0 /* flags */);
}
Reference in New Issue Copy Permalink