sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/cogl/cogl-buffer-private.h

164 lines
4.9 KiB
C
Raw Normal View History

cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
*
* Authors:
* Damien Lespiau <damien.lespiau@intel.com>
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
* Robert Bragg <robert@linux.intel.com>
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
*/
#ifndef __COGL_BUFFER_PRIVATE_H__
#define __COGL_BUFFER_PRIVATE_H__
#include <glib.h>
pixel-buffer: Replace CoglHandle with CoglPixelBuffer * One more file converted to stop using CoglHandle re:a8c8cbee513
2010-07-03 19:24:36 +00:00
#include "cogl.h"
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
#include "cogl-object-private.h"
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
#include "cogl-buffer.h"
G_BEGIN_DECLS
#define COGL_BUFFER(buffer) ((CoglBuffer *)(buffer))
typedef struct _CoglBufferVtable CoglBufferVtable;
struct _CoglBufferVtable
{
cogl-buffer: Use void* instead of guint8* for map and set_data Unless the CoglBuffer is being used for texture data then it's relatively unlikely that the data will contain an array of bytes. For example if it's used as a vertex array then it's more likely to be floats or some vertex struct. In that case it's much more convenient if set_data and map use void* pointers so that we can avoid a cast.
2010-11-04 16:01:23 +00:00
void * (* map) (CoglBuffer *buffer,
CoglBufferAccess access,
CoglBufferMapHint hints);
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
void (* unmap) (CoglBuffer *buffer);
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
gboolean (* set_data) (CoglBuffer *buffer,
unsigned int offset,
cogl-buffer: Use void* instead of guint8* for map and set_data Unless the CoglBuffer is being used for texture data then it's relatively unlikely that the data will contain an array of bytes. For example if it's used as a vertex array then it's more likely to be floats or some vertex struct. In that case it's much more convenient if set_data and map use void* pointers so that we can avoid a cast.
2010-11-04 16:01:23 +00:00
const void *data,
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
unsigned int size);
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
};
typedef enum _CoglBufferFlags
{
cogl: Fallback to set_data when mapping a buffer to fill it In the journal code and when generating the stroke path the vertices are generated on the fly and stored in a CoglBuffer using cogl_buffer_map. However cogl_buffer_map is allowed to fail but it wasn't checking for a NULL return value. In particular on GLES it will always fail because glMapBuffer is only provided by an extension. This adds a new pair of internal functions called _cogl_buffer_{un,}map_for_fill_or_fallback which wrap cogl_buffer_map. If the map fails then it will instead return a pointer into a GByteArray attached to the context. When the buffer is unmapped the array is copied into the buffer using cogl_buffer_set_data.
2011-01-13 15:35:30 +00:00
COGL_BUFFER_FLAG_NONE = 0,
COGL_BUFFER_FLAG_BUFFER_OBJECT = 1UL << 0, /* real openGL buffer object */
COGL_BUFFER_FLAG_MAPPED = 1UL << 1,
COGL_BUFFER_FLAG_MAPPED_FALLBACK = 1UL << 2
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
} CoglBufferFlags;
cogl-buffer: make the COGL_BUFFER_USAGE_HINT private The usage hint should be implied by the CoglBuffer subclass type so the public getter and setter APIs for manually changing the usage hint of a CoglBuffer have now been removed.
2010-07-03 20:30:33 +00:00
typedef enum {
COGL_BUFFER_USAGE_HINT_TEXTURE,
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
COGL_BUFFER_USAGE_HINT_ATTRIBUTE_BUFFER,
buffer: BufferBindTarget + BufferUsageHint enum renaming This renames the BufferBindTarget + BufferUsageHint enums to match the anticipated new APIs for "index arrays" and "vertex arrays" as opposed to using the terms "vertices" or "indices".
2010-10-26 15:05:00 +00:00
COGL_BUFFER_USAGE_HINT_INDEX_ARRAY
cogl-buffer: make the COGL_BUFFER_USAGE_HINT private The usage hint should be implied by the CoglBuffer subclass type so the public getter and setter APIs for manually changing the usage hint of a CoglBuffer have now been removed.
2010-07-03 20:30:33 +00:00
} CoglBufferUsageHint;
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
typedef enum {
COGL_BUFFER_BIND_TARGET_PIXEL_PACK,
COGL_BUFFER_BIND_TARGET_PIXEL_UNPACK,
Rename CoglVertexArray to CoglAttributeBuffer This is part of a broader cleanup of some of the experimental Cogl API. One of the reasons for this particular rename is to switch away from using the term "Array" which implies a regular, indexable layout which isn't the case. We also want to have a strongly implied relationship between CoglAttributes and CoglAttributeBuffers.
2011-03-02 15:01:41 +00:00
COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER,
buffer: BufferBindTarget + BufferUsageHint enum renaming This renames the BufferBindTarget + BufferUsageHint enums to match the anticipated new APIs for "index arrays" and "vertex arrays" as opposed to using the terms "vertices" or "indices".
2010-10-26 15:05:00 +00:00
COGL_BUFFER_BIND_TARGET_INDEX_ARRAY,
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
COGL_BUFFER_BIND_TARGET_COUNT
} CoglBufferBindTarget;
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
struct _CoglBuffer
{
pixel-buffer: Replace CoglHandle with CoglPixelBuffer * One more file converted to stop using CoglHandle re:a8c8cbee513
2010-07-03 19:24:36 +00:00
CoglObject _parent;
cogl-buffer: Move malloc fallback logic into CoglBuffer Since we'll want to share the fallback logic with CoglVertexArray this moves the malloc based fallback (for when OpenGL doesn't support vertex or pixel buffer objects) into cogl-buffer.c.
2010-07-06 00:21:43 +00:00
CoglBufferVtable vtable;
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
CoglBufferBindTarget last_target;
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
CoglBufferFlags flags;
GLuint gl_handle; /* OpenGL handle */
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-10 01:57:32 +00:00
unsigned int size; /* size of the buffer, in bytes */
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
CoglBufferUsageHint usage_hint;
CoglBufferUpdateHint update_hint;
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-10 01:57:32 +00:00
guint8 *data; /* points to the mapped memory when
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
* the CoglBuffer is a VBO, PBO, ... or
* points to allocated memory in the
* fallback paths */
buffer: Add a store_created bit field member This adds a store_created bit field to CoglBuffer so we know if the underlying buffer has been allocated yet. Previously the code was trying to do something really wrong by accidentally using the COGL_PIXEL_ARRAY_FLAG_IS_SET macro (note "PIXEL_ARRAY") and what is more odd was the declaration of a CoglPixelArray *pixel_array in cogl-buffer.c which the buffer was being cast too before calling using the macro. Probably this was the fall-out of some previous code re-factoring.
2010-10-26 15:06:46 +00:00
buffer: adds immutable ref/unref mechanism This adds an internal mechanism to mark that a buffer is in-use so that a warning can be generated if the user attempts to modify the buffer. The plans is for the journal to use this mechanism so that we can warn users about mid-scene modifications of buffers.
2010-10-26 18:08:51 +00:00
int immutable_ref;
buffer: Add a store_created bit field member This adds a store_created bit field to CoglBuffer so we know if the underlying buffer has been allocated yet. Previously the code was trying to do something really wrong by accidentally using the COGL_PIXEL_ARRAY_FLAG_IS_SET macro (note "PIXEL_ARRAY") and what is more odd was the declaration of a CoglPixelArray *pixel_array in cogl-buffer.c which the buffer was being cast too before calling using the macro. Probably this was the fall-out of some previous code re-factoring.
2010-10-26 15:06:46 +00:00
guint store_created:1;
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
};
cogl-buffer: Handle subclass registration like cogl-texture Instead of having to extend cogl_is_buffer with new buffer types manually this now adds a new COGL_BUFFER_DEFINE macro to be used instead of COGL_OBJECT_DEFINE for CoglBuffer subclasses. This macro will automatically register the new type with ctx->buffer_types which will iterated by cogl_is_buffer. This is the same coding pattern used for CoglTexture.
2010-07-03 22:56:44 +00:00
/* This is used to register a type to the list of handle types that
will be considered a texture in cogl_is_texture() */
void
_cogl_buffer_register_buffer_type (GQuark type);
#define COGL_BUFFER_DEFINE(TypeName, type_name) \
COGL_OBJECT_DEFINE_WITH_CODE \
(TypeName, type_name, \
_cogl_buffer_register_buffer_type (_cogl_object_ \
## type_name ## _get_type ()))
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
void
_cogl_buffer_initialize (CoglBuffer *buffer,
unsigned int size,
cogl-buffer: Move malloc fallback logic into CoglBuffer Since we'll want to share the fallback logic with CoglVertexArray this moves the malloc based fallback (for when OpenGL doesn't support vertex or pixel buffer objects) into cogl-buffer.c.
2010-07-06 00:21:43 +00:00
gboolean use_malloc,
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
CoglBufferBindTarget default_target,
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
CoglBufferUsageHint usage_hint,
CoglBufferUpdateHint update_hint);
cogl-buffer: Handle subclass registration like cogl-texture Instead of having to extend cogl_is_buffer with new buffer types manually this now adds a new COGL_BUFFER_DEFINE macro to be used instead of COGL_OBJECT_DEFINE for CoglBuffer subclasses. This macro will automatically register the new type with ctx->buffer_types which will iterated by cogl_is_buffer. This is the same coding pattern used for CoglTexture.
2010-07-03 22:56:44 +00:00
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
void
_cogl_buffer_fini (CoglBuffer *buffer);
buffer: make _bind() return base pointer We now make _cogl_buffer_bind return a base pointer for the bound buffer which can be used with OpenGL. The pointer will be NULL for GPU based buffers or may point to an malloc'd buffer. Since OpenGL expects an offset instead of a pointer when dealing with buffer objects this means we can handle fallback malloc buffers and GPU buffers in a consistent way.
2010-10-12 12:14:17 +00:00
void *
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
_cogl_buffer_bind (CoglBuffer *buffer,
cogl-buffer: Track the last used bind target in CoglBuffer This makes CoglBuffer track the last used bind target as a private property. This is later used when binding a buffer to map instead of always using the PIXEL_UNPACK target. This also adds some additional sanity checks that code doesn't try to nest binds to the same target or bind a buffer to multiple targets at the same time.
2010-07-05 22:24:34 +00:00
CoglBufferBindTarget target);
void
_cogl_buffer_unbind (CoglBuffer *buffer);
cogl-buffer: make the COGL_BUFFER_USAGE_HINT private The usage hint should be implied by the CoglBuffer subclass type so the public getter and setter APIs for manually changing the usage hint of a CoglBuffer have now been removed.
2010-07-03 20:30:33 +00:00
CoglBufferUsageHint
_cogl_buffer_get_usage_hint (CoglBuffer *buffer);
cogl-buffer-private.h: cleanup up the coding style This file was following the Clutter coding style of arranging prototypes into columns which Cogl doesn't copy.
2010-07-03 23:18:10 +00:00
GLenum
_cogl_buffer_access_to_gl_enum (CoglBufferAccess access);
GLenum
_cogl_buffer_hints_to_gl_enum (CoglBufferUsageHint usage_hint,
CoglBufferUpdateHint update_hint);
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
buffer: adds immutable ref/unref mechanism This adds an internal mechanism to mark that a buffer is in-use so that a warning can be generated if the user attempts to modify the buffer. The plans is for the journal to use this mechanism so that we can warn users about mid-scene modifications of buffers.
2010-10-26 18:08:51 +00:00
CoglBuffer *
_cogl_buffer_immutable_ref (CoglBuffer *buffer);
void
_cogl_buffer_immutable_unref (CoglBuffer *buffer);
cogl: Fallback to set_data when mapping a buffer to fill it In the journal code and when generating the stroke path the vertices are generated on the fly and stored in a CoglBuffer using cogl_buffer_map. However cogl_buffer_map is allowed to fail but it wasn't checking for a NULL return value. In particular on GLES it will always fail because glMapBuffer is only provided by an extension. This adds a new pair of internal functions called _cogl_buffer_{un,}map_for_fill_or_fallback which wrap cogl_buffer_map. If the map fails then it will instead return a pointer into a GByteArray attached to the context. When the buffer is unmapped the array is copied into the buffer using cogl_buffer_set_data.
2011-01-13 15:35:30 +00:00
/* This is a wrapper around cogl_buffer_map for internal use when we
want to map the buffer for write only to replace the entire
contents. If the map fails then it will fallback to writing to a
temporary buffer. When _cogl_buffer_unmap_for_fill_or_fallback is
called the temporary buffer will be copied into the array. Note
that these calls share a global array so they can not be nested. */
void *
_cogl_buffer_map_for_fill_or_fallback (CoglBuffer *buffer);
void
_cogl_buffer_unmap_for_fill_or_fallback (CoglBuffer *buffer);
cogl-buffer: add an abstract class around openGL's buffer objects Buffer objects are cool! This abstracts the buffer API first introduced by GL_ARB_vertex_buffer_object and then extended to other objects. The coglBuffer abstract class is intended to be the base class of all the buffer objects, letting the user map() buffers. If the underlying implementation does not support buffer objects (or only support VBO but not FBO for instance), fallback paths should be provided.
2010-01-10 17:28:24 +00:00
G_END_DECLS
#endif /* __COGL_BUFFER_PRIVATE_H__ */
Copy permalink