[cogl] Rename CoglVertexArray to CoglAttributeBuffer
- From: Robert Bragg <rbragg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [cogl] Rename CoglVertexArray to CoglAttributeBuffer
- Date: Mon, 16 May 2011 13:55:56 +0000 (UTC)
commit ce7c06dc039189f8d7ebe971864bf3d109fa6324
Author: Robert Bragg <robert linux intel com>
Date: Wed Mar 2 15:01:41 2011 +0000
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.
cogl/Makefile.am | 6 +-
...y-private.h => cogl-attribute-buffer-private.h} | 9 +-
...cogl-vertex-array.c => cogl-attribute-buffer.c} | 24 ++--
...cogl-vertex-array.h => cogl-attribute-buffer.h} | 30 +++---
cogl/cogl-attribute-private.h | 2 +-
cogl/cogl-attribute.c | 49 +++++----
cogl/cogl-attribute.h | 11 +-
cogl/cogl-buffer-private.h | 4 +-
cogl/cogl-buffer.c | 2 +-
cogl/cogl-index-array.c | 7 +-
cogl/cogl-journal.c | 32 +++---
cogl/cogl-path-private.h | 10 +-
cogl/cogl-primitive-private.h | 2 +-
cogl/cogl-primitive.c | 80 +++++++-------
cogl/cogl-primitive.h | 16 ++--
cogl/cogl-primitives.c | 21 ++--
cogl/cogl-vertex-buffer-private.h | 4 +-
cogl/cogl-vertex-buffer.c | 41 ++++----
cogl/cogl.h | 2 +-
cogl/cogl2-path.c | 112 ++++++++++----------
20 files changed, 235 insertions(+), 229 deletions(-)
---
diff --git a/cogl/Makefile.am b/cogl/Makefile.am
index ae0d374..f79a710 100644
--- a/cogl/Makefile.am
+++ b/cogl/Makefile.am
@@ -77,7 +77,7 @@ cogl_public_h = \
$(srcdir)/cogl-types.h \
$(srcdir)/cogl-vertex-buffer.h \
$(srcdir)/cogl-index-array.h \
- $(srcdir)/cogl-vertex-array.h \
+ $(srcdir)/cogl-attribute-buffer.h \
$(srcdir)/cogl-indices.h \
$(srcdir)/cogl-attribute.h \
$(srcdir)/cogl-primitive.h \
@@ -222,8 +222,8 @@ cogl_sources_c = \
$(srcdir)/cogl-vertex-buffer.c \
$(srcdir)/cogl-index-array-private.h \
$(srcdir)/cogl-index-array.c \
- $(srcdir)/cogl-vertex-array-private.h \
- $(srcdir)/cogl-vertex-array.c \
+ $(srcdir)/cogl-attribute-buffer-private.h \
+ $(srcdir)/cogl-attribute-buffer.c \
$(srcdir)/cogl-indices-private.h \
$(srcdir)/cogl-indices.c \
$(srcdir)/cogl-attribute-private.h \
diff --git a/cogl/cogl-vertex-array-private.h b/cogl/cogl-attribute-buffer-private.h
similarity index 85%
rename from cogl/cogl-vertex-array-private.h
rename to cogl/cogl-attribute-buffer-private.h
index f24c7de..13141d7 100644
--- a/cogl/cogl-vertex-array-private.h
+++ b/cogl/cogl-attribute-buffer-private.h
@@ -25,15 +25,14 @@
* Robert Bragg <robert linux intel com>
*/
-#ifndef __COGL_VERTEX_ARRAY_PRIVATE_H
-#define __COGL_VERTEX_ARRAY_PRIVATE_H
+#ifndef __COGL_ATTRIBUTE_BUFFER_PRIVATE_H
+#define __COGL_ATTRIBUTE_BUFFER_PRIVATE_H
#include "cogl-buffer-private.h"
-struct _CoglVertexArray
+struct _CoglAttributeBuffer
{
CoglBuffer _parent;
};
-#endif /* __COGL_VERTEX_ARRAY_PRIVATE_H */
-
+#endif /* __COGL_ATTRIBUTE_BUFFER_PRIVATE_H */
diff --git a/cogl/cogl-vertex-array.c b/cogl/cogl-attribute-buffer.c
similarity index 70%
rename from cogl/cogl-vertex-array.c
rename to cogl/cogl-attribute-buffer.c
index 965135c..981c93e 100644
--- a/cogl/cogl-vertex-array.c
+++ b/cogl/cogl-attribute-buffer.c
@@ -30,17 +30,17 @@
#endif
#include "cogl-object-private.h"
-#include "cogl-vertex-array.h"
-#include "cogl-vertex-array-private.h"
+#include "cogl-attribute-buffer.h"
+#include "cogl-attribute-buffer-private.h"
-static void _cogl_vertex_array_free (CoglVertexArray *array);
+static void _cogl_attribute_buffer_free (CoglAttributeBuffer *array);
-COGL_BUFFER_DEFINE (VertexArray, vertex_array);
+COGL_BUFFER_DEFINE (AttributeBuffer, attribute_buffer);
-CoglVertexArray *
-cogl_vertex_array_new (gsize bytes, const void *data)
+CoglAttributeBuffer *
+cogl_attribute_buffer_new (gsize bytes, const void *data)
{
- CoglVertexArray *array = g_slice_new (CoglVertexArray);
+ CoglAttributeBuffer *array = g_slice_new (CoglAttributeBuffer);
gboolean use_malloc;
if (!cogl_features_available (COGL_FEATURE_VBOS))
@@ -52,11 +52,11 @@ cogl_vertex_array_new (gsize bytes, const void *data)
_cogl_buffer_initialize (COGL_BUFFER (array),
bytes,
use_malloc,
- COGL_BUFFER_BIND_TARGET_VERTEX_ARRAY,
- COGL_BUFFER_USAGE_HINT_VERTEX_ARRAY,
+ COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER,
+ COGL_BUFFER_USAGE_HINT_ATTRIBUTE_BUFFER,
COGL_BUFFER_UPDATE_HINT_STATIC);
- _cogl_vertex_array_object_new (array);
+ _cogl_attribute_buffer_object_new (array);
if (data)
cogl_buffer_set_data (COGL_BUFFER (array),
@@ -67,11 +67,11 @@ cogl_vertex_array_new (gsize bytes, const void *data)
}
static void
-_cogl_vertex_array_free (CoglVertexArray *array)
+_cogl_attribute_buffer_free (CoglAttributeBuffer *array)
{
/* parent's destructor */
_cogl_buffer_fini (COGL_BUFFER (array));
- g_slice_free (CoglVertexArray, array);
+ g_slice_free (CoglAttributeBuffer, array);
}
diff --git a/cogl/cogl-vertex-array.h b/cogl/cogl-attribute-buffer.h
similarity index 69%
rename from cogl/cogl-vertex-array.h
rename to cogl/cogl-attribute-buffer.h
index 2d8ddbb..270f76a 100644
--- a/cogl/cogl-vertex-array.h
+++ b/cogl/cogl-attribute-buffer.h
@@ -28,26 +28,27 @@
#error "Only <cogl/cogl.h> can be included directly."
#endif
-#ifndef __COGL_VERTEX_ARRAY_H__
-#define __COGL_VERTEX_ARRAY_H__
+#ifndef __COGL_ATTRIBUTE_BUFFER_H__
+#define __COGL_ATTRIBUTE_BUFFER_H__
G_BEGIN_DECLS
/**
- * SECTION:cogl-vertex-array
- * @short_description: Functions for creating and manipulating vertex arrays
+ * SECTION:cogl-attribute-buffer
+ * @short_description: Functions for creating and manipulating attribute
+ * buffers
*
* FIXME
*/
-typedef struct _CoglVertexArray CoglVertexArray;
+typedef struct _CoglAttributeBuffer CoglAttributeBuffer;
/**
- * cogl_vertex_array_new:
+ * cogl_attribute_buffer_new:
* @bytes: The number of bytes to allocate for vertex attribute data.
* @data: An optional pointer to vertex data to upload immediately.
*
- * Declares a new #CoglVertexArray of @size bytes to contain arrays of vertex
+ * Declares a new #CoglAttributeBuffer of @size bytes to contain arrays of vertex
* attribute data. Once declared, data can be set using cogl_buffer_set_data()
* or by mapping it into the application's address space using cogl_buffer_map().
*
@@ -57,26 +58,25 @@ typedef struct _CoglVertexArray CoglVertexArray;
* Since: 1.4
* Stability: Unstable
*/
-CoglVertexArray *
-cogl_vertex_array_new (gsize bytes,
- const void *data);
+CoglAttributeBuffer *
+cogl_attribute_buffer_new (gsize bytes, const void *data);
/**
- * cogl_is_vertex_array:
+ * cogl_is_attribute_buffer:
* @object: A #CoglObject
*
- * Gets whether the given object references a #CoglVertexArray.
+ * Gets whether the given object references a #CoglAttributeBuffer.
*
- * Returns: %TRUE if the handle references a #CoglVertexArray,
+ * Returns: %TRUE if the handle references a #CoglAttributeBuffer,
* %FALSE otherwise
*
* Since: 1.4
* Stability: Unstable
*/
gboolean
-cogl_is_vertex_array (void *object);
+cogl_is_attribute_buffer (void *object);
G_END_DECLS
-#endif /* __COGL_VERTEX_ARRAY_H__ */
+#endif /* __COGL_ATTRIBUTE_BUFFER_H__ */
diff --git a/cogl/cogl-attribute-private.h b/cogl/cogl-attribute-private.h
index d7acef6..6a04d43 100644
--- a/cogl/cogl-attribute-private.h
+++ b/cogl/cogl-attribute-private.h
@@ -44,7 +44,7 @@ struct _CoglAttribute
{
CoglObject _parent;
- CoglVertexArray *array;
+ CoglAttributeBuffer *attribute_buffer;
char *name;
CoglAttributeNameID name_id;
gsize stride;
diff --git a/cogl/cogl-attribute.c b/cogl/cogl-attribute.c
index 591313d..e27c9e7 100644
--- a/cogl/cogl-attribute.c
+++ b/cogl/cogl-attribute.c
@@ -231,7 +231,7 @@ validate_cogl_attribute (const char *name,
}
CoglAttribute *
-cogl_attribute_new (CoglVertexArray *array,
+cogl_attribute_new (CoglAttributeBuffer *attribute_buffer,
const char *name,
gsize stride,
gsize offset,
@@ -241,7 +241,7 @@ cogl_attribute_new (CoglVertexArray *array,
CoglAttribute *attribute = g_slice_new (CoglAttribute);
gboolean status;
- attribute->array = cogl_object_ref (array);
+ attribute->attribute_buffer = cogl_object_ref (attribute_buffer);
attribute->name = g_strdup (name);
attribute->stride = stride;
attribute->offset = offset;
@@ -312,27 +312,27 @@ cogl_attribute_set_normalized (CoglAttribute *attribute,
attribute->normalized = normalized;
}
-CoglVertexArray *
-cogl_attribute_get_array (CoglAttribute *attribute)
+CoglAttributeBuffer *
+cogl_attribute_get_buffer (CoglAttribute *attribute)
{
g_return_val_if_fail (cogl_is_attribute (attribute), NULL);
- return attribute->array;
+ return attribute->attribute_buffer;
}
void
cogl_attribute_set_array (CoglAttribute *attribute,
- CoglVertexArray *array)
+ CoglAttributeBuffer *attribute_buffer)
{
g_return_if_fail (cogl_is_attribute (attribute));
if (G_UNLIKELY (attribute->immutable_ref))
warn_about_midscene_changes ();
- cogl_object_ref (array);
+ cogl_object_ref (attribute_buffer);
- cogl_object_unref (attribute->array);
- attribute->array = array;
+ cogl_object_unref (attribute->attribute_buffer);
+ attribute->attribute_buffer = attribute_buffer;
}
CoglAttribute *
@@ -341,7 +341,7 @@ _cogl_attribute_immutable_ref (CoglAttribute *attribute)
g_return_val_if_fail (cogl_is_attribute (attribute), NULL);
attribute->immutable_ref++;
- _cogl_buffer_immutable_ref (COGL_BUFFER (attribute->array));
+ _cogl_buffer_immutable_ref (COGL_BUFFER (attribute->attribute_buffer));
return attribute;
}
@@ -352,14 +352,14 @@ _cogl_attribute_immutable_unref (CoglAttribute *attribute)
g_return_if_fail (attribute->immutable_ref > 0);
attribute->immutable_ref--;
- _cogl_buffer_immutable_unref (COGL_BUFFER (attribute->array));
+ _cogl_buffer_immutable_unref (COGL_BUFFER (attribute->attribute_buffer));
}
static void
_cogl_attribute_free (CoglAttribute *attribute)
{
g_free (attribute->name);
- cogl_object_unref (attribute->array);
+ cogl_object_unref (attribute->attribute_buffer);
g_slice_free (CoglAttribute, attribute);
}
@@ -598,16 +598,16 @@ enable_gl_state (CoglDrawFlags flags,
for (i = 0; attributes[i]; i++)
{
CoglAttribute *attribute = attributes[i];
- CoglVertexArray *vertex_array;
+ CoglAttributeBuffer *attribute_buffer;
CoglBuffer *buffer;
guint8 *base;
#ifdef HAVE_COGL_GLES2
int attrib_location;
#endif
- vertex_array = cogl_attribute_get_array (attribute);
- buffer = COGL_BUFFER (vertex_array);
- base = _cogl_buffer_bind (buffer, COGL_BUFFER_BIND_TARGET_VERTEX_ARRAY);
+ attribute_buffer = cogl_attribute_get_buffer (attribute);
+ buffer = COGL_BUFFER (attribute_buffer);
+ base = _cogl_buffer_bind (buffer, COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER);
switch (attribute->name_id)
{
@@ -875,7 +875,7 @@ get_wire_lines (CoglAttribute *attribute,
int *n_vertices_out,
CoglIndices *_indices)
{
- CoglVertexArray *vertex_array = cogl_attribute_get_array (attribute);
+ CoglAttributeBuffer *attribute_buffer = cogl_attribute_get_buffer (attribute);
void *vertices;
CoglIndexArray *index_array;
void *indices;
@@ -884,7 +884,7 @@ get_wire_lines (CoglAttribute *attribute,
int n_lines;
CoglVertexP3 *out = NULL;
- vertices = cogl_buffer_map (COGL_BUFFER (vertex_array),
+ vertices = cogl_buffer_map (COGL_BUFFER (attribute_buffer),
COGL_BUFFER_ACCESS_READ, 0);
if (_indices)
{
@@ -982,7 +982,7 @@ get_wire_lines (CoglAttribute *attribute,
#endif
if (vertices != NULL)
- cogl_buffer_unmap (COGL_BUFFER (vertex_array));
+ cogl_buffer_unmap (COGL_BUFFER (attribute_buffer));
if (indices != NULL)
cogl_buffer_unmap (COGL_BUFFER (index_array));
@@ -1003,7 +1003,7 @@ draw_wireframe (CoglVerticesMode mode,
static CoglPipeline *wire_pipeline;
CoglAttribute *wire_attribute[2];
CoglVertexP3 *lines;
- CoglVertexArray *array;
+ CoglAttributeBuffer *attribute_buffer;
for (i = 0; attributes[i]; i++)
{
@@ -1021,16 +1021,17 @@ draw_wireframe (CoglVerticesMode mode,
n_vertices,
&n_line_vertices,
indices);
- array = cogl_vertex_array_new (sizeof (CoglVertexP3) * n_line_vertices,
- lines);
+ attribute_buffer =
+ cogl_attribute_buffer_new (sizeof (CoglVertexP3) * n_line_vertices,
+ lines);
wire_attribute[0] =
- cogl_attribute_new (array, "cogl_position_in",
+ cogl_attribute_new (attribute_buffer, "cogl_position_in",
sizeof (CoglVertexP3),
0,
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
wire_attribute[1] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
if (!wire_pipeline)
{
diff --git a/cogl/cogl-attribute.h b/cogl/cogl-attribute.h
index 70d4c2b..0abeb3c 100644
--- a/cogl/cogl-attribute.h
+++ b/cogl/cogl-attribute.h
@@ -31,7 +31,7 @@
#ifndef __COGL_ATTRIBUTE_H__
#define __COGL_ATTRIBUTE_H__
-#include <cogl/cogl-vertex-array.h>
+#include <cogl/cogl-attribute-buffer.h>
#include <cogl/cogl-indices.h>
G_BEGIN_DECLS
@@ -48,13 +48,14 @@ typedef struct _CoglAttribute CoglAttribute;
/**
* cogl_attribute_new:
- * @array: The #CoglVertexArray containing the actual attribute data
+ * @attribute_buffer: The #CoglAttributeBuffer containing the actual
+ * attribute data
* @name: The name of the attribute (used to reference it from GLSL)
* @stride: The number of bytes to jump to get to the next attribute
* value for the next vertex. (Usually
* <pre>sizeof (MyVertex)</pre>)
- * @offset: The byte offset from the start of @array for the first
- * attribute value. (Usually
+ * @offset: The byte offset from the start of @attribute_buffer for
+ * the first attribute value. (Usually
* <pre>offsetof (MyVertex, component0)</pre>
* @components: The number of components (e.g. 4 for an rgba color or
* 3 for and (x,y,z) position)
@@ -131,7 +132,7 @@ typedef struct _CoglAttribute CoglAttribute;
/* XXX: look for a precedent to see if the stride/offset args should
* have a different order. */
CoglAttribute *
-cogl_attribute_new (CoglVertexArray *array,
+cogl_attribute_new (CoglAttributeBuffer *attribute_buffer,
const char *name,
gsize stride,
gsize offset,
diff --git a/cogl/cogl-buffer-private.h b/cogl/cogl-buffer-private.h
index fc79e7d..0a1d5ec 100644
--- a/cogl/cogl-buffer-private.h
+++ b/cogl/cogl-buffer-private.h
@@ -64,14 +64,14 @@ typedef enum _CoglBufferFlags
typedef enum {
COGL_BUFFER_USAGE_HINT_TEXTURE,
- COGL_BUFFER_USAGE_HINT_VERTEX_ARRAY,
+ COGL_BUFFER_USAGE_HINT_ATTRIBUTE_BUFFER,
COGL_BUFFER_USAGE_HINT_INDEX_ARRAY
} CoglBufferUsageHint;
typedef enum {
COGL_BUFFER_BIND_TARGET_PIXEL_PACK,
COGL_BUFFER_BIND_TARGET_PIXEL_UNPACK,
- COGL_BUFFER_BIND_TARGET_VERTEX_ARRAY,
+ COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER,
COGL_BUFFER_BIND_TARGET_INDEX_ARRAY,
COGL_BUFFER_BIND_TARGET_COUNT
diff --git a/cogl/cogl-buffer.c b/cogl/cogl-buffer.c
index 3caaa94..ff62566 100644
--- a/cogl/cogl-buffer.c
+++ b/cogl/cogl-buffer.c
@@ -128,7 +128,7 @@ convert_bind_target_to_gl_target (CoglBufferBindTarget target)
return GL_PIXEL_PACK_BUFFER;
case COGL_BUFFER_BIND_TARGET_PIXEL_UNPACK:
return GL_PIXEL_UNPACK_BUFFER;
- case COGL_BUFFER_BIND_TARGET_VERTEX_ARRAY:
+ case COGL_BUFFER_BIND_TARGET_ATTRIBUTE_BUFFER:
return GL_ARRAY_BUFFER;
case COGL_BUFFER_BIND_TARGET_INDEX_ARRAY:
return GL_ELEMENT_ARRAY_BUFFER;
diff --git a/cogl/cogl-index-array.c b/cogl/cogl-index-array.c
index 2a85151..0c81cc2 100644
--- a/cogl/cogl-index-array.c
+++ b/cogl/cogl-index-array.c
@@ -98,13 +98,14 @@ cogl_index_array_allocate (CoglIndexArray *indices,
*
* XXX: The double plurel form that "Indices" "Array" implies could be
* a bit confusing. Also to be a bit more consistent with
- * CoglVertexArray vs CoglAttribute it might be best to rename so
+ * CoglAttributeBuffer vs CoglAttribute it might be best to rename so
* we have CoglIndexArray vs CoglIndices? maybe even
* CoglIndexRange :-/ ?
*
* CoglBuffer
- * CoglVertexArray (buffer sub-class)
- * CoglPrimitive (defines meta data for sub-region of array)
+ * CoglAttributeBuffer (buffer sub-class)
+ * CoglAttribute (defines meta data for sub-region of buffer)
+ * CoglPrimitive (object encapsulating a set of attributes)
* CoglPixelArray (buffer sub-class)
* CoglIndexArray (buffer sub-class)
* CoglIndices (defines meta data for sub-region of array)
diff --git a/cogl/cogl-journal.c b/cogl/cogl-journal.c
index b0fbac7..262d794 100644
--- a/cogl/cogl-journal.c
+++ b/cogl/cogl-journal.c
@@ -95,7 +95,7 @@ typedef struct _CoglJournalFlushState
{
CoglJournal *journal;
- CoglVertexArray *vertex_array;
+ CoglAttributeBuffer *attribute_buffer;
GArray *attributes;
int current_attribute;
@@ -518,7 +518,7 @@ _cogl_journal_flush_texcoord_vbo_offsets_and_entries (
/* XXX: it may be worth having some form of static initializer for
* attributes... */
*attribute_entry =
- cogl_attribute_new (state->vertex_array,
+ cogl_attribute_new (state->attribute_buffer,
name,
state->stride,
state->array_offset +
@@ -593,7 +593,7 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
g_array_set_size (state->attributes, 2);
attribute_entry = &g_array_index (state->attributes, CoglAttribute *, 0);
- *attribute_entry = cogl_attribute_new (state->vertex_array,
+ *attribute_entry = cogl_attribute_new (state->attribute_buffer,
"cogl_position_in",
stride,
state->array_offset,
@@ -602,7 +602,7 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
attribute_entry = &g_array_index (state->attributes, CoglAttribute *, 1);
*attribute_entry =
- cogl_attribute_new (state->vertex_array,
+ cogl_attribute_new (state->attribute_buffer,
"cogl_color_in",
stride,
state->array_offset + (POS_STRIDE * 4),
@@ -614,9 +614,9 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
#endif
/* We only create new Attributes when the stride within the
- * VertexArray changes. (due to a change in the number of pipeline
+ * AttributeBuffer changes. (due to a change in the number of pipeline
* layers) While the stride remains constant we walk forward through
- * the above VertexArray using a vertex offset passed to
+ * the above AttributeBuffer using a vertex offset passed to
* cogl_draw_attributes
*/
state->current_vertex = 0;
@@ -628,15 +628,15 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
/* Mapping a buffer for read is probably a really bad thing to
do but this will only happen during debugging so it probably
doesn't matter */
- verts = ((guint8 *) cogl_buffer_map (COGL_BUFFER (state->vertex_array),
- COGL_BUFFER_ACCESS_READ, 0) +
+ verts = ((guint8 *)cogl_buffer_map (COGL_BUFFER (state->attribute_buffer),
+ COGL_BUFFER_ACCESS_READ, 0) +
state->array_offset);
_cogl_journal_dump_quad_batch (verts,
batch_start->n_layers,
batch_len);
- cogl_buffer_unmap (COGL_BUFFER (state->vertex_array));
+ cogl_buffer_unmap (COGL_BUFFER (state->attribute_buffer));
}
batch_and_call (batch_start,
@@ -1092,13 +1092,13 @@ compare_entry_clip_stacks (CoglJournalEntry *entry0, CoglJournalEntry *entry1)
return entry0->clip_stack == entry1->clip_stack;
}
-static CoglVertexArray *
+static CoglAttributeBuffer *
upload_vertices (const CoglJournalEntry *entries,
int n_entries,
size_t needed_vbo_len,
GArray *vertices)
{
- CoglVertexArray *array;
+ CoglAttributeBuffer *attribute_buffer;
CoglBuffer *buffer;
const float *vin;
float *vout;
@@ -1107,8 +1107,8 @@ upload_vertices (const CoglJournalEntry *entries,
g_assert (needed_vbo_len);
- array = cogl_vertex_array_new (needed_vbo_len * 4, NULL);
- buffer = COGL_BUFFER (array);
+ attribute_buffer = cogl_attribute_buffer_new (needed_vbo_len * 4, NULL);
+ buffer = COGL_BUFFER (attribute_buffer);
cogl_buffer_set_update_hint (buffer, COGL_BUFFER_UPDATE_HINT_STATIC);
vout = _cogl_buffer_map_for_fill_or_fallback (buffer);
@@ -1182,7 +1182,7 @@ upload_vertices (const CoglJournalEntry *entries,
_cogl_buffer_unmap_for_fill_or_fallback (buffer);
- return array;
+ return attribute_buffer;
}
void
@@ -1340,7 +1340,7 @@ _cogl_journal_flush (CoglJournal *journal,
/* We upload the vertices after the clip stack pass in case it
modifies the entries */
- state.vertex_array = upload_vertices (&g_array_index (journal->entries,
+ state.attribute_buffer = upload_vertices (&g_array_index (journal->entries,
CoglJournalEntry, 0),
journal->entries->len,
journal->needed_vbo_len,
@@ -1380,7 +1380,7 @@ _cogl_journal_flush (CoglJournal *journal,
cogl_object_unref (g_array_index (state.attributes, CoglAttribute *, i));
g_array_set_size (state.attributes, 0);
- cogl_object_unref (state.vertex_array);
+ cogl_object_unref (state.attribute_buffer);
_cogl_journal_discard (journal);
diff --git a/cogl/cogl-path-private.h b/cogl/cogl-path-private.h
index dbd23f4..e85bf3a 100644
--- a/cogl/cogl-path-private.h
+++ b/cogl/cogl-path-private.h
@@ -79,14 +79,14 @@ struct _CoglPathData
floatVec2 path_nodes_min;
floatVec2 path_nodes_max;
- CoglVertexArray *fill_vbo;
+ CoglAttributeBuffer *fill_attribute_buffer;
CoglIndices *fill_vbo_indices;
unsigned int fill_vbo_n_indices;
- CoglAttribute *fill_vbo_attributes[COGL_PATH_N_ATTRIBUTES + 1];
+ CoglAttribute *fill_attributes[COGL_PATH_N_ATTRIBUTES + 1];
- CoglVertexArray *stroke_vbo;
- CoglAttribute **stroke_vbo_attributes;
- unsigned int stroke_vbo_n_attributes;
+ CoglAttributeBuffer *stroke_attribute_buffer;
+ CoglAttribute **stroke_attributes;
+ unsigned int stroke_n_attributes;
/* This is used as an optimisation for when the path contains a
single contour specified using cogl2_path_rectangle. Cogl is more
diff --git a/cogl/cogl-primitive-private.h b/cogl/cogl-primitive-private.h
index 1569489..c50181f 100644
--- a/cogl/cogl-primitive-private.h
+++ b/cogl/cogl-primitive-private.h
@@ -29,7 +29,7 @@
#define __COGL_PRIMITIVE_PRIVATE_H
#include "cogl-object-private.h"
-#include "cogl-vertex-array-private.h"
+#include "cogl-attribute-buffer-private.h"
struct _CoglPrimitive
{
diff --git a/cogl/cogl-primitive.c b/cogl/cogl-primitive.c
index 9b76241..821ba76 100644
--- a/cogl/cogl-primitive.c
+++ b/cogl/cogl-primitive.c
@@ -124,11 +124,11 @@ cogl_primitive_new_p2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP2), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP2), data);
CoglAttribute *attributes[2];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP2),
offsetof (CoglVertexP2, x),
@@ -136,7 +136,7 @@ cogl_primitive_new_p2 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[1] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -147,11 +147,11 @@ cogl_primitive_new_p3 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP3), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP3), data);
CoglAttribute *attributes[2];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP3),
offsetof (CoglVertexP3, x),
@@ -159,7 +159,7 @@ cogl_primitive_new_p3 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[1] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -170,17 +170,17 @@ cogl_primitive_new_p2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2C4 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP2C4), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP2C4), data);
CoglAttribute *attributes[3];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP2C4),
offsetof (CoglVertexP2C4, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_color_in",
sizeof (CoglVertexP2C4),
offsetof (CoglVertexP2C4, r),
@@ -188,7 +188,7 @@ cogl_primitive_new_p2c4 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
attributes[2] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -199,17 +199,17 @@ cogl_primitive_new_p3c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3C4 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP3C4), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP3C4), data);
CoglAttribute *attributes[3];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP3C4),
offsetof (CoglVertexP3C4, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_color_in",
sizeof (CoglVertexP3C4),
offsetof (CoglVertexP3C4, r),
@@ -217,7 +217,7 @@ cogl_primitive_new_p3c4 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
attributes[2] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -228,17 +228,17 @@ cogl_primitive_new_p2t2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2T2 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP2T2), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP2T2), data);
CoglAttribute *attributes[3];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP2T2),
offsetof (CoglVertexP2T2, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP2T2),
offsetof (CoglVertexP2T2, s),
@@ -246,7 +246,7 @@ cogl_primitive_new_p2t2 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[2] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -257,17 +257,17 @@ cogl_primitive_new_p3t2 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3T2 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP3T2), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP3T2), data);
CoglAttribute *attributes[3];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP3T2),
offsetof (CoglVertexP3T2, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP3T2),
offsetof (CoglVertexP3T2, s),
@@ -275,7 +275,7 @@ cogl_primitive_new_p3t2 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[2] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -286,23 +286,23 @@ cogl_primitive_new_p2t2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP2T2C4 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP2T2C4), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP2T2C4), data);
CoglAttribute *attributes[4];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, x),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[2] = cogl_attribute_new (array,
+ attributes[2] = cogl_attribute_new (attribute_buffer,
"cogl_color_in",
sizeof (CoglVertexP2T2C4),
offsetof (CoglVertexP2T2C4, r),
@@ -310,7 +310,7 @@ cogl_primitive_new_p2t2c4 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
attributes[3] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
@@ -321,23 +321,23 @@ cogl_primitive_new_p3t2c4 (CoglVerticesMode mode,
int n_vertices,
const CoglVertexP3T2C4 *data)
{
- CoglVertexArray *array =
- cogl_vertex_array_new (n_vertices * sizeof (CoglVertexP3T2C4), data);
+ CoglAttributeBuffer *attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * sizeof (CoglVertexP3T2C4), data);
CoglAttribute *attributes[4];
- attributes[0] = cogl_attribute_new (array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, x),
3,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[1] = cogl_attribute_new (array,
+ attributes[1] = cogl_attribute_new (attribute_buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, s),
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
- attributes[2] = cogl_attribute_new (array,
+ attributes[2] = cogl_attribute_new (attribute_buffer,
"cogl_color_in",
sizeof (CoglVertexP3T2C4),
offsetof (CoglVertexP3T2C4, r),
@@ -345,7 +345,7 @@ cogl_primitive_new_p3t2c4 (CoglVerticesMode mode,
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
attributes[3] = NULL;
- cogl_object_unref (array);
+ cogl_object_unref (attribute_buffer);
return _cogl_primitive_new_with_attributes_array_unref (mode, n_vertices,
attributes);
diff --git a/cogl/cogl-primitive.h b/cogl/cogl-primitive.h
index d286841..758d297 100644
--- a/cogl/cogl-primitive.h
+++ b/cogl/cogl-primitive.h
@@ -245,7 +245,7 @@ cogl_primitive_new_with_attributes_array (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position
+ * necessary #CoglAttributeBuffer storage, describe the position
* attribute with a #CoglAttribute and upload your data.
*
* For example to draw a convex polygon you can do:
@@ -289,7 +289,7 @@ cogl_primitive_new_p2 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position
+ * necessary #CoglAttributeBuffer storage, describe the position
* attribute with a #CoglAttribute and upload your data.
*
* For example to draw a convex polygon you can do:
@@ -333,7 +333,7 @@ cogl_primitive_new_p3 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position
+ * necessary #CoglAttributeBuffer storage, describe the position
* and color attributes with #CoglAttribute<!-- -->s and upload
* your data.
*
@@ -379,7 +379,7 @@ cogl_primitive_new_p2c4 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position
+ * necessary #CoglAttributeBuffer storage, describe the position
* and color attributes with #CoglAttribute<!-- -->s and upload
* your data.
*
@@ -425,7 +425,7 @@ cogl_primitive_new_p3c4 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position and
+ * necessary #CoglAttributeBuffer storage, describe the position and
* texture coordinate attributes with #CoglAttribute<!-- -->s and
* upload your data.
*
@@ -471,7 +471,7 @@ cogl_primitive_new_p2t2 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position and
+ * necessary #CoglAttributeBuffer storage, describe the position and
* texture coordinate attributes with #CoglAttribute<!-- -->s and
* upload your data.
*
@@ -517,7 +517,7 @@ cogl_primitive_new_p3t2 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position, texture
+ * necessary #CoglAttributeBuffer storage, describe the position, texture
* coordinate and color attributes with #CoglAttribute<!-- -->s and
* upload your data.
*
@@ -563,7 +563,7 @@ cogl_primitive_new_p2t2c4 (CoglVerticesMode mode,
*
* Provides a convenient way to describe a primitive, such as a single
* triangle strip or a triangle fan, that will internally allocate the
- * necessary #CoglVertexArray storage, describe the position, texture
+ * necessary #CoglAttributeBuffer storage, describe the position, texture
* coordinate and color attributes with #CoglAttribute<!-- -->s and
* upload your data.
*
diff --git a/cogl/cogl-primitives.c b/cogl/cogl-primitives.c
index 2931126..84ed222 100644
--- a/cogl/cogl-primitives.c
+++ b/cogl/cogl-primitives.c
@@ -933,11 +933,11 @@ _cogl_rectangle_immediate (float x_1,
x_2, y_1,
x_2, y_2
};
- CoglVertexArray *vertex_array;
+ CoglAttributeBuffer *attribute_buffer;
CoglAttribute *attributes[2];
- vertex_array = cogl_vertex_array_new (sizeof (vertices), vertices);
- attributes[0] = cogl_attribute_new (vertex_array,
+ attribute_buffer = cogl_attribute_buffer_new (sizeof (vertices), vertices);
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
sizeof (float) * 2, /* stride */
0, /* offset */
@@ -955,7 +955,7 @@ _cogl_rectangle_immediate (float x_1,
cogl_object_unref (attributes[0]);
- cogl_object_unref (vertex_array);
+ cogl_object_unref (attribute_buffer);
}
typedef struct _AppendTexCoordsState
@@ -1050,7 +1050,7 @@ cogl_polygon (const CoglTextureVertex *vertices,
int i;
unsigned int stride;
gsize stride_bytes;
- CoglVertexArray *vertex_array;
+ CoglAttributeBuffer *attribute_buffer;
float *v;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@@ -1080,9 +1080,10 @@ cogl_polygon (const CoglTextureVertex *vertices,
* but still support any number of vertices */
g_array_set_size (ctx->polygon_vertices, n_vertices * stride);
- vertex_array = cogl_vertex_array_new (n_vertices * stride_bytes, NULL);
+ attribute_buffer =
+ cogl_attribute_buffer_new (n_vertices * stride_bytes, NULL);
- attributes[0] = cogl_attribute_new (vertex_array,
+ attributes[0] = cogl_attribute_new (attribute_buffer,
"cogl_position_in",
stride_bytes,
0,
@@ -1104,7 +1105,7 @@ cogl_polygon (const CoglTextureVertex *vertices,
char *name = i < 8 ? (char *)names[i] :
g_strdup_printf ("cogl_tex_coord%d_in", i);
- attributes[i + 1] = cogl_attribute_new (vertex_array,
+ attributes[i + 1] = cogl_attribute_new (attribute_buffer,
name,
stride_bytes,
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
@@ -1116,7 +1117,7 @@ cogl_polygon (const CoglTextureVertex *vertices,
if (use_color)
{
attributes[n_attributes - 1] =
- cogl_attribute_new (vertex_array,
+ cogl_attribute_new (attribute_buffer,
"cogl_color_in",
stride_bytes,
/* NB: [X,Y,Z,TX,TY...,R,G,B,A,...] */
@@ -1159,7 +1160,7 @@ cogl_polygon (const CoglTextureVertex *vertices,
}
v = (float *)ctx->polygon_vertices->data;
- cogl_buffer_set_data (COGL_BUFFER (vertex_array),
+ cogl_buffer_set_data (COGL_BUFFER (attribute_buffer),
0,
v,
ctx->polygon_vertices->len * sizeof (float));
diff --git a/cogl/cogl-vertex-buffer-private.h b/cogl/cogl-vertex-buffer-private.h
index 096c00b..a7b23c8 100644
--- a/cogl/cogl-vertex-buffer-private.h
+++ b/cogl/cogl-vertex-buffer-private.h
@@ -124,8 +124,8 @@ typedef struct _CoglVertexBufferVBO
{
CoglVertexBufferVBOFlags flags;
- CoglVertexArray *array;
- size_t array_bytes;
+ CoglAttributeBuffer *attribute_buffer;
+ size_t buffer_bytes;
GList *attributes;
} CoglVertexBufferVBO;
diff --git a/cogl/cogl-vertex-buffer.c b/cogl/cogl-vertex-buffer.c
index 300acf0..3778130 100644
--- a/cogl/cogl-vertex-buffer.c
+++ b/cogl/cogl-vertex-buffer.c
@@ -833,8 +833,8 @@ filter_strided_attribute (CoglVertexBufferAttrib *attribute,
new_cogl_vbo->attributes =
g_list_prepend (new_cogl_vbo->attributes, attribute);
/* Any one of the interleved attributes will have the same span_bytes */
- new_cogl_vbo->array = NULL;
- new_cogl_vbo->array_bytes = attribute->span_bytes;
+ new_cogl_vbo->attribute_buffer = NULL;
+ new_cogl_vbo->buffer_bytes = attribute->span_bytes;
new_cogl_vbo->flags = COGL_VERTEX_BUFFER_VBO_FLAG_STRIDED;
if (attribute->flags & COGL_VERTEX_BUFFER_ATTRIB_FLAG_INFREQUENT_RESUBMIT)
@@ -942,7 +942,7 @@ cogl_vertex_buffer_vbo_free (CoglVertexBufferVBO *cogl_vbo)
g_list_free (cogl_vbo->attributes);
if (cogl_vbo->flags & COGL_VERTEX_BUFFER_VBO_FLAG_SUBMITTED)
- cogl_object_unref (cogl_vbo->array);
+ cogl_object_unref (cogl_vbo->attribute_buffer);
g_slice_free (CoglVertexBufferVBO, cogl_vbo);
}
@@ -988,7 +988,7 @@ upload_multipack_vbo_via_map_buffer (CoglVertexBufferVBO *cogl_vbo)
_COGL_GET_CONTEXT (ctx, FALSE);
- buf = cogl_buffer_map (COGL_BUFFER (cogl_vbo->array),
+ buf = cogl_buffer_map (COGL_BUFFER (cogl_vbo->attribute_buffer),
COGL_BUFFER_ACCESS_WRITE,
COGL_BUFFER_MAP_HINT_DISCARD);
if (!buf)
@@ -1009,7 +1009,7 @@ upload_multipack_vbo_via_map_buffer (CoglVertexBufferVBO *cogl_vbo)
offset += attribute_size;
}
- cogl_buffer_unmap (COGL_BUFFER (cogl_vbo->array));
+ cogl_buffer_unmap (COGL_BUFFER (cogl_vbo->attribute_buffer));
return TRUE;
}
@@ -1028,7 +1028,7 @@ upload_multipack_vbo_via_buffer_sub_data (CoglVertexBufferVBO *cogl_vbo)
PAD_FOR_ALIGNMENT (offset, type_size);
- cogl_buffer_set_data (COGL_BUFFER (cogl_vbo->array),
+ cogl_buffer_set_data (COGL_BUFFER (cogl_vbo->attribute_buffer),
offset,
attribute->u.pointer,
attribute_size);
@@ -1050,15 +1050,15 @@ upload_attributes (CoglVertexBufferVBO *cogl_vbo)
usage = COGL_BUFFER_UPDATE_HINT_DYNAMIC;
else
usage = COGL_BUFFER_UPDATE_HINT_STATIC;
- cogl_buffer_set_update_hint (COGL_BUFFER (cogl_vbo->array), usage);
+ cogl_buffer_set_update_hint (COGL_BUFFER (cogl_vbo->attribute_buffer), usage);
if (cogl_vbo->flags & COGL_VERTEX_BUFFER_VBO_FLAG_STRIDED)
{
const void *pointer = prep_strided_vbo_for_upload (cogl_vbo);
- cogl_buffer_set_data (COGL_BUFFER (cogl_vbo->array),
+ cogl_buffer_set_data (COGL_BUFFER (cogl_vbo->attribute_buffer),
0, /* offset */
pointer,
- cogl_vbo->array_bytes);
+ cogl_vbo->buffer_bytes);
}
else /* MULTIPACK */
{
@@ -1107,10 +1107,11 @@ cogl_vertex_buffer_vbo_resolve (CoglVertexBuffer *buffer,
/* See if we can re-use this now empty VBO: */
if (!found_target_vbo
- && conflict_vbo->array_bytes == new_cogl_vbo->array_bytes)
+ && conflict_vbo->buffer_bytes == new_cogl_vbo->buffer_bytes)
{
found_target_vbo = TRUE;
- new_cogl_vbo->array = cogl_object_ref (conflict_vbo->array);
+ new_cogl_vbo->attribute_buffer =
+ cogl_object_ref (conflict_vbo->attribute_buffer);
cogl_vertex_buffer_vbo_free (conflict_vbo);
upload_attributes (new_cogl_vbo);
@@ -1132,8 +1133,8 @@ cogl_vertex_buffer_vbo_resolve (CoglVertexBuffer *buffer,
if (!found_target_vbo)
{
- new_cogl_vbo->array = cogl_vertex_array_new (new_cogl_vbo->array_bytes,
- NULL);
+ new_cogl_vbo->attribute_buffer =
+ cogl_attribute_buffer_new (new_cogl_vbo->buffer_bytes, NULL);
upload_attributes (new_cogl_vbo);
*final_vbos = g_list_prepend (*final_vbos, new_cogl_vbo);
@@ -1181,7 +1182,7 @@ update_primitive_attributes (CoglVertexBuffer *buffer)
if (G_UNLIKELY (!attribute->attribute))
{
attribute->attribute =
- cogl_attribute_new (cogl_vbo->array,
+ cogl_attribute_new (cogl_vbo->attribute_buffer,
attribute->name_without_detail,
attribute->stride,
attribute->u.vbo_offset,
@@ -1346,8 +1347,8 @@ cogl_vertex_buffer_submit_real (CoglVertexBuffer *buffer)
*/
new_multipack_vbo = g_slice_alloc (sizeof (CoglVertexBufferVBO));
- new_multipack_vbo->array = NULL;
- new_multipack_vbo->array_bytes = 0;
+ new_multipack_vbo->attribute_buffer = NULL;
+ new_multipack_vbo->buffer_bytes = 0;
new_multipack_vbo->flags =
COGL_VERTEX_BUFFER_VBO_FLAG_MULTIPACK
| COGL_VERTEX_BUFFER_VBO_FLAG_INFREQUENT_RESUBMIT;
@@ -1400,8 +1401,8 @@ cogl_vertex_buffer_submit_real (CoglVertexBuffer *buffer)
cogl_vbo->attributes = NULL;
cogl_vbo->attributes = g_list_prepend (cogl_vbo->attributes,
attribute);
- cogl_vbo->array = NULL;
- cogl_vbo->array_bytes = attribute->span_bytes;
+ cogl_vbo->attribute_buffer = NULL;
+ cogl_vbo->buffer_bytes = attribute->span_bytes;
new_vbos = g_list_prepend (new_vbos, cogl_vbo);
}
else
@@ -1423,9 +1424,9 @@ cogl_vertex_buffer_submit_real (CoglVertexBuffer *buffer)
* is based on the adjacent attribute.
*/
- PAD_FOR_ALIGNMENT (new_multipack_vbo->array_bytes, type_size);
+ PAD_FOR_ALIGNMENT (new_multipack_vbo->buffer_bytes, type_size);
- new_multipack_vbo->array_bytes += attribute->span_bytes;
+ new_multipack_vbo->buffer_bytes += attribute->span_bytes;
}
}
diff --git a/cogl/cogl.h b/cogl/cogl.h
index 52c2940..50160f0 100644
--- a/cogl/cogl.h
+++ b/cogl/cogl.h
@@ -81,7 +81,7 @@ typedef struct _CoglFramebuffer CoglFramebuffer;
#include <cogl/cogl-quaternion.h>
#include <cogl/cogl-texture-3d.h>
#include <cogl/cogl-index-array.h>
-#include <cogl/cogl-vertex-array.h>
+#include <cogl/cogl-attribute-buffer.h>
#include <cogl/cogl-indices.h>
#include <cogl/cogl-attribute.h>
#include <cogl/cogl-primitive.h>
diff --git a/cogl/cogl2-path.c b/cogl/cogl2-path.c
index b9d1ea1..fa5e53a 100644
--- a/cogl/cogl2-path.c
+++ b/cogl/cogl2-path.c
@@ -52,8 +52,8 @@
static void _cogl_path_free (CoglPath *path);
-static void _cogl_path_build_fill_vbo (CoglPath *path);
-static void _cogl_path_build_stroke_vbo (CoglPath *path);
+static void _cogl_path_build_fill_attribute_buffer (CoglPath *path);
+static void _cogl_path_build_stroke_attribute_buffer (CoglPath *path);
COGL_OBJECT_DEFINE (Path, path);
@@ -62,27 +62,27 @@ _cogl_path_data_clear_vbos (CoglPathData *data)
{
int i;
- if (data->fill_vbo)
+ if (data->fill_attribute_buffer)
{
- cogl_object_unref (data->fill_vbo);
+ cogl_object_unref (data->fill_attribute_buffer);
cogl_object_unref (data->fill_vbo_indices);
for (i = 0; i < COGL_PATH_N_ATTRIBUTES; i++)
- cogl_object_unref (data->fill_vbo_attributes[i]);
+ cogl_object_unref (data->fill_attributes[i]);
- data->fill_vbo = NULL;
+ data->fill_attribute_buffer = NULL;
}
- if (data->stroke_vbo)
+ if (data->stroke_attribute_buffer)
{
- cogl_object_unref (data->stroke_vbo);
+ cogl_object_unref (data->stroke_attribute_buffer);
- for (i = 0; i < data->stroke_vbo_n_attributes; i++)
- cogl_object_unref (data->stroke_vbo_attributes[i]);
+ for (i = 0; i < data->stroke_n_attributes; i++)
+ cogl_object_unref (data->stroke_attributes[i]);
- g_free (data->stroke_vbo_attributes);
+ g_free (data->stroke_attributes);
- data->stroke_vbo = NULL;
+ data->stroke_attribute_buffer = NULL;
}
}
@@ -118,13 +118,13 @@ _cogl_path_modify (CoglPath *path)
old_data->path_nodes->data,
old_data->path_nodes->len);
- path->data->fill_vbo = COGL_INVALID_HANDLE;
+ path->data->fill_attribute_buffer = NULL;
path->data->ref_count = 1;
_cogl_path_data_unref (old_data);
}
/* The path is altered so the vbo will now be invalid */
- else if (path->data->fill_vbo)
+ else if (path->data->fill_attribute_buffer)
_cogl_path_data_clear_vbos (path->data);
}
@@ -228,7 +228,7 @@ _cogl_path_stroke_nodes (CoglPath *path)
source = copy;
}
- _cogl_path_build_stroke_vbo (path);
+ _cogl_path_build_stroke_attribute_buffer (path);
cogl_push_source (source);
@@ -240,7 +240,7 @@ _cogl_path_stroke_nodes (CoglPath *path)
cogl_draw_attributes (COGL_VERTICES_MODE_LINE_STRIP,
0, node->path_size,
- data->stroke_vbo_attributes[path_num],
+ data->stroke_attributes[path_num],
NULL);
path_num++;
@@ -341,14 +341,14 @@ _cogl_path_fill_nodes (CoglPath *path)
}
}
- _cogl_path_build_fill_vbo (path);
+ _cogl_path_build_fill_attribute_buffer (path);
_cogl_draw_indexed_attributes_array
(COGL_VERTICES_MODE_TRIANGLES,
0, /* first_vertex */
path->data->fill_vbo_n_indices,
path->data->fill_vbo_indices,
- path->data->fill_vbo_attributes,
+ path->data->fill_attributes,
COGL_DRAW_SKIP_JOURNAL_FLUSH |
COGL_DRAW_SKIP_PIPELINE_VALIDATION |
COGL_DRAW_SKIP_FRAMEBUFFER_FLUSH);
@@ -1009,8 +1009,8 @@ cogl2_path_new (void)
data->fill_rule = COGL_PATH_FILL_RULE_EVEN_ODD;
data->path_nodes = g_array_new (FALSE, FALSE, sizeof (CoglPathNode));
data->last_path = 0;
- data->fill_vbo = COGL_INVALID_HANDLE;
- data->stroke_vbo = NULL;
+ data->fill_attribute_buffer = NULL;
+ data->stroke_attribute_buffer = NULL;
data->is_rectangle = FALSE;
return _cogl_path_object_new (path);
@@ -1389,7 +1389,7 @@ _cogl_path_tesselator_combine (double coords[3],
}
static void
-_cogl_path_build_fill_vbo (CoglPath *path)
+_cogl_path_build_fill_attribute_buffer (CoglPath *path)
{
CoglPathTesselator tess;
unsigned int path_start = 0;
@@ -1397,7 +1397,7 @@ _cogl_path_build_fill_vbo (CoglPath *path)
int i;
/* If we've already got a vbo then we don't need to do anything */
- if (data->fill_vbo)
+ if (data->fill_attribute_buffer)
return;
tess.primitive_type = FALSE;
@@ -1480,27 +1480,28 @@ _cogl_path_build_fill_vbo (CoglPath *path)
gluDeleteTess (tess.glu_tess);
- data->fill_vbo = cogl_vertex_array_new (sizeof (CoglPathTesselatorVertex) *
- tess.vertices->len,
- tess.vertices->data);
+ data->fill_attribute_buffer =
+ cogl_attribute_buffer_new (sizeof (CoglPathTesselatorVertex) *
+ tess.vertices->len,
+ tess.vertices->data);
g_array_free (tess.vertices, TRUE);
- data->fill_vbo_attributes[0] =
- cogl_attribute_new (data->fill_vbo,
- "cogl_position_in",
- sizeof (CoglPathTesselatorVertex),
- G_STRUCT_OFFSET (CoglPathTesselatorVertex, x),
- 2, /* n_components */
- COGL_ATTRIBUTE_TYPE_FLOAT);
- data->fill_vbo_attributes[1] =
- cogl_attribute_new (data->fill_vbo,
- "cogl_tex_coord0_in",
- sizeof (CoglPathTesselatorVertex),
- G_STRUCT_OFFSET (CoglPathTesselatorVertex, s),
- 2, /* n_components */
- COGL_ATTRIBUTE_TYPE_FLOAT);
+ data->fill_attributes[0] =
+ cogl_attribute_new (data->fill_attribute_buffer,
+ "cogl_position_in",
+ sizeof (CoglPathTesselatorVertex),
+ G_STRUCT_OFFSET (CoglPathTesselatorVertex, x),
+ 2, /* n_components */
+ COGL_ATTRIBUTE_TYPE_FLOAT);
+ data->fill_attributes[1] =
+ cogl_attribute_new (data->fill_attribute_buffer,
+ "cogl_tex_coord0_in",
+ sizeof (CoglPathTesselatorVertex),
+ G_STRUCT_OFFSET (CoglPathTesselatorVertex, s),
+ 2, /* n_components */
+ COGL_ATTRIBUTE_TYPE_FLOAT);
/* NULL terminator */
- data->fill_vbo_attributes[2] = NULL;
+ data->fill_attributes[2] = NULL;
data->fill_vbo_indices = cogl_indices_new (tess.indices_type,
tess.indices->data,
@@ -1510,25 +1511,26 @@ _cogl_path_build_fill_vbo (CoglPath *path)
}
static void
-_cogl_path_build_stroke_vbo (CoglPath *path)
+_cogl_path_build_stroke_attribute_buffer (CoglPath *path)
{
CoglPathData *data = path->data;
+ CoglBuffer *buffer;
unsigned int n_attributes = 0;
unsigned int path_start;
CoglPathNode *node;
- floatVec2 *vbo_p;
+ floatVec2 *buffer_p;
unsigned int i;
/* If we've already got a cached vbo then we don't need to do anything */
- if (data->stroke_vbo)
+ if (data->stroke_attribute_buffer)
return;
- data->stroke_vbo = cogl_vertex_array_new (data->path_nodes->len *
- sizeof (floatVec2),
- NULL);
+ data->stroke_attribute_buffer =
+ cogl_attribute_buffer_new (data->path_nodes->len * sizeof (floatVec2),
+ NULL);
- vbo_p =
- _cogl_buffer_map_for_fill_or_fallback (COGL_BUFFER (data->stroke_vbo));
+ buffer = COGL_BUFFER (data->stroke_attribute_buffer);
+ buffer_p = _cogl_buffer_map_for_fill_or_fallback (buffer);
/* Copy the vertices in and count the number of sub paths. Each sub
path will form a separate attribute so we can paint the disjoint
@@ -1541,16 +1543,16 @@ _cogl_path_build_stroke_vbo (CoglPath *path)
for (i = 0; i < node->path_size; i++)
{
- vbo_p[path_start + i].x = node[i].x;
- vbo_p[path_start + i].y = node[i].y;
+ buffer_p[path_start + i].x = node[i].x;
+ buffer_p[path_start + i].y = node[i].y;
}
n_attributes++;
}
- _cogl_buffer_unmap_for_fill_or_fallback (COGL_BUFFER (data->stroke_vbo));
+ _cogl_buffer_unmap_for_fill_or_fallback (buffer);
- data->stroke_vbo_attributes = g_new (CoglAttribute *, n_attributes);
+ data->stroke_attributes = g_new (CoglAttribute *, n_attributes);
/* Now we can loop the sub paths again to create the attributes */
for (i = 0, path_start = 0;
@@ -1559,8 +1561,8 @@ _cogl_path_build_stroke_vbo (CoglPath *path)
{
node = &g_array_index (data->path_nodes, CoglPathNode, path_start);
- data->stroke_vbo_attributes[i] =
- cogl_attribute_new (data->stroke_vbo,
+ data->stroke_attributes[i] =
+ cogl_attribute_new (data->stroke_attribute_buffer,
"cogl_position_in",
sizeof (floatVec2),
path_start * sizeof (floatVec2),
@@ -1568,5 +1570,5 @@ _cogl_path_build_stroke_vbo (CoglPath *path)
COGL_ATTRIBUTE_TYPE_FLOAT);
}
- data->stroke_vbo_n_attributes = n_attributes;
+ data->stroke_n_attributes = n_attributes;
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
