isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-10 07:56:14 -05:00
Code Issues Packages Projects Releases Wiki Activity
013548c109
mutter/cogl/cogl-primitive-private.h

65 lines
1.6 KiB
C
Raw Normal View History

cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifndef __COGL_PRIMITIVE_PRIVATE_H
#define __COGL_PRIMITIVE_PRIVATE_H
#include "cogl-object-private.h"
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
#include "cogl-attribute-buffer-private.h"
primitive: Adds _cogl_primitive_draw api taking flags This adds an internal _cogl_primitive_draw API that takes CoglDrawFlags like _cogl_draw_attributes does which allows us to draw a primitive but skip things like flushing journals, flushing framebuffer state and avoid validating the current pipeline. This allows us to draw primitives in places that could otherwise cause recursion. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 13:45:16 -04:00
#include "cogl-attribute-private.h"
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
struct _CoglPrimitive
{
CoglObject _parent;
Reorder some struct members to avoid padding due to alignment This tweaks the ordering of some struct members in some of the more important structs so that the compiler won't insert wasted padding to avoid breaking the alignment. Some members that were previously unsigned long have been changed to unsigned int. These members need to be able to fit in 32-bits to run on 32-bit machines anyway so there's no point in having them extend to 64-bit on 64-bit machines. This doesn't affect the public API. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit b721af236680005464e39f7f4dd11381d95efb16)
2013-01-10 09:21:04 -05:00
CoglIndices *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
CoglVerticesMode mode;
int first_vertex;
int n_vertices;
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
int 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
CoglAttribute **attributes;
int n_attributes;
int n_embedded_attributes;
CoglAttribute *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: 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);
void
_cogl_primitive_immutable_unref (CoglPrimitive *primitive);
primitive: Adds _cogl_primitive_draw api taking flags This adds an internal _cogl_primitive_draw API that takes CoglDrawFlags like _cogl_draw_attributes does which allows us to draw a primitive but skip things like flushing journals, flushing framebuffer state and avoid validating the current pipeline. This allows us to draw primitives in places that could otherwise cause recursion. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-25 13:45:16 -04:00
void
_cogl_primitive_draw (CoglPrimitive *primitive,
CoglDrawFlags flags);
cogl: Adds experimental CoglPrimitive API A CoglPrimitive is a retainable object for drawing a single primitive, such as a triangle strip, fan or list. CoglPrimitives build on CoglVertexAttributes and CoglIndices which themselves build on CoglVertexArrays and CoglIndexArrays respectively. A CoglPrimitive encapsulates enough information such that it can be retained in a queue (e.g. the Cogl Journal, or renderlists in the future) and drawn at some later time.
2010-10-12 07:54:07 -04:00
#endif /* __COGL_PRIMITIVE_PRIVATE_H */
Reference in New Issue Copy Permalink