#include "main/glheader.h"
+#include "main/arrayobj.h"
#include "main/bufferobj.h"
#include "main/context.h"
#include "main/dlist.h"
#include "main/enums.h"
#include "main/eval.h"
#include "main/macros.h"
-#include "main/api_validate.h"
+#include "main/draw_validate.h"
#include "main/api_arrayelt.h"
#include "main/vtxfmt.h"
#include "main/dispatch.h"
#include "main/state.h"
+#include "main/varray.h"
#include "util/bitscan.h"
+#include "util/u_memory.h"
-#include "vbo_context.h"
#include "vbo_noop.h"
#include "vbo_private.h"
const fi_type * src_buffer)
{
struct vbo_save_context *save = &vbo_context(ctx)->save;
- const struct _mesa_prim *prim = &node->prims[node->prim_count - 1];
- GLuint nr = prim->count;
+ struct _mesa_prim *prim = &node->prims[node->prim_count - 1];
GLuint sz = save->vertex_size;
const fi_type *src = src_buffer + prim->start * sz;
fi_type *dst = save->copied.buffer;
- GLuint ovf, i;
if (prim->end)
return 0;
- switch (prim->mode) {
- case GL_POINTS:
- return 0;
- case GL_LINES:
- ovf = nr & 1;
- for (i = 0; i < ovf; i++)
- memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
- sz * sizeof(GLfloat));
- return i;
- case GL_TRIANGLES:
- ovf = nr % 3;
- for (i = 0; i < ovf; i++)
- memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
- sz * sizeof(GLfloat));
- return i;
- case GL_QUADS:
- ovf = nr & 3;
- for (i = 0; i < ovf; i++)
- memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
- sz * sizeof(GLfloat));
- return i;
- case GL_LINE_STRIP:
- if (nr == 0)
- return 0;
- else {
- memcpy(dst, src + (nr - 1) * sz, sz * sizeof(GLfloat));
- return 1;
- }
- case GL_LINE_LOOP:
- case GL_TRIANGLE_FAN:
- case GL_POLYGON:
- if (nr == 0)
- return 0;
- else if (nr == 1) {
- memcpy(dst, src + 0, sz * sizeof(GLfloat));
- return 1;
- }
- else {
- memcpy(dst, src + 0, sz * sizeof(GLfloat));
- memcpy(dst + sz, src + (nr - 1) * sz, sz * sizeof(GLfloat));
- return 2;
- }
- case GL_TRIANGLE_STRIP:
- case GL_QUAD_STRIP:
- switch (nr) {
- case 0:
- ovf = 0;
- break;
- case 1:
- ovf = 1;
- break;
- default:
- ovf = 2 + (nr & 1);
- break;
- }
- for (i = 0; i < ovf; i++)
- memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
- sz * sizeof(GLfloat));
- return i;
- default:
- unreachable("Unexpected primitive type");
- return 0;
- }
+ return vbo_copy_vertices(ctx, prim->mode, prim, sz, true, dst, src);
}
vertex_store->buffer_map = NULL;
vertex_store->used = 0;
- vertex_store->refcount = 1;
return vertex_store;
}
* previous prim.
*/
static void
-merge_prims(struct _mesa_prim *prim_list,
+merge_prims(struct gl_context *ctx, struct _mesa_prim *prim_list,
GLuint *prim_count)
{
GLuint i;
vbo_try_prim_conversion(this_prim);
- if (vbo_can_merge_prims(prev_prim, this_prim)) {
+ if (vbo_merge_draws(ctx, true, prev_prim, this_prim)) {
/* We've found a prim that just extend the previous one. Tack it
* onto the previous one, and let this primitive struct get dropped.
*/
- vbo_merge_prims(prev_prim, this_prim);
continue;
}
}
+/* Compare the present vao if it has the same setup. */
+static bool
+compare_vao(gl_vertex_processing_mode mode,
+ const struct gl_vertex_array_object *vao,
+ const struct gl_buffer_object *bo, GLintptr buffer_offset,
+ GLuint stride, GLbitfield64 vao_enabled,
+ const GLubyte size[VBO_ATTRIB_MAX],
+ const GLenum16 type[VBO_ATTRIB_MAX],
+ const GLuint offset[VBO_ATTRIB_MAX])
+{
+ if (!vao)
+ return false;
+
+ /* If the enabled arrays are not the same we are not equal. */
+ if (vao_enabled != vao->Enabled)
+ return false;
+
+ /* Check the buffer binding at 0 */
+ if (vao->BufferBinding[0].BufferObj != bo)
+ return false;
+ /* BufferBinding[0].Offset != buffer_offset is checked per attribute */
+ if (vao->BufferBinding[0].Stride != stride)
+ return false;
+ assert(vao->BufferBinding[0].InstanceDivisor == 0);
+
+ /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space */
+ const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
+
+ /* Now check the enabled arrays */
+ GLbitfield mask = vao_enabled;
+ while (mask) {
+ const int attr = u_bit_scan(&mask);
+ const unsigned char vbo_attr = vao_to_vbo_map[attr];
+ const GLenum16 tp = type[vbo_attr];
+ const GLintptr off = offset[vbo_attr] + buffer_offset;
+ const struct gl_array_attributes *attrib = &vao->VertexAttrib[attr];
+ if (attrib->RelativeOffset + vao->BufferBinding[0].Offset != off)
+ return false;
+ if (attrib->Format.Type != tp)
+ return false;
+ if (attrib->Format.Size != size[vbo_attr])
+ return false;
+ assert(attrib->Format.Format == GL_RGBA);
+ assert(attrib->Format.Normalized == GL_FALSE);
+ assert(attrib->Format.Integer == vbo_attrtype_to_integer_flag(tp));
+ assert(attrib->Format.Doubles == vbo_attrtype_to_double_flag(tp));
+ assert(attrib->BufferBindingIndex == 0);
+ }
+
+ return true;
+}
+
+
+/* Create or reuse the vao for the vertex processing mode. */
+static void
+update_vao(struct gl_context *ctx,
+ gl_vertex_processing_mode mode,
+ struct gl_vertex_array_object **vao,
+ struct gl_buffer_object *bo, GLintptr buffer_offset,
+ GLuint stride, GLbitfield64 vbo_enabled,
+ const GLubyte size[VBO_ATTRIB_MAX],
+ const GLenum16 type[VBO_ATTRIB_MAX],
+ const GLuint offset[VBO_ATTRIB_MAX])
+{
+ /* Compute the bitmasks of vao_enabled arrays */
+ GLbitfield vao_enabled = _vbo_get_vao_enabled_from_vbo(mode, vbo_enabled);
+
+ /*
+ * Check if we can possibly reuse the exisiting one.
+ * In the long term we should reset them when something changes.
+ */
+ if (compare_vao(mode, *vao, bo, buffer_offset, stride,
+ vao_enabled, size, type, offset))
+ return;
+
+ /* The initial refcount is 1 */
+ _mesa_reference_vao(ctx, vao, NULL);
+ *vao = _mesa_new_vao(ctx, ~((GLuint)0));
+
+ /*
+ * assert(stride <= ctx->Const.MaxVertexAttribStride);
+ * MaxVertexAttribStride is not set for drivers that does not
+ * expose GL 44 or GLES 31.
+ */
+
+ /* Bind the buffer object at binding point 0 */
+ _mesa_bind_vertex_buffer(ctx, *vao, 0, bo, buffer_offset, stride, false,
+ false);
+
+ /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space
+ * Note that the position/generic0 aliasing is done in the VAO.
+ */
+ const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
+ /* Now set the enable arrays */
+ GLbitfield mask = vao_enabled;
+ while (mask) {
+ const int vao_attr = u_bit_scan(&mask);
+ const GLubyte vbo_attr = vao_to_vbo_map[vao_attr];
+ assert(offset[vbo_attr] <= ctx->Const.MaxVertexAttribRelativeOffset);
+
+ _vbo_set_attrib_format(ctx, *vao, vao_attr, buffer_offset,
+ size[vbo_attr], type[vbo_attr], offset[vbo_attr]);
+ _mesa_vertex_attrib_binding(ctx, *vao, vao_attr, 0);
+ }
+ _mesa_enable_vertex_array_attribs(ctx, *vao, vao_enabled);
+ assert(vao_enabled == (*vao)->Enabled);
+ assert((vao_enabled & ~(*vao)->VertexAttribBufferMask) == 0);
+
+ /* Finalize and freeze the VAO */
+ _mesa_set_vao_immutable(ctx, *vao);
+}
+
+
/**
* Insert the active immediate struct onto the display list currently
* being built.
/* Duplicate our template, increment refcounts to the storage structs:
*/
- node->enabled = save->enabled;
- memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));
- memcpy(node->attrtype, save->attrtype, sizeof(node->attrtype));
- node->vertex_size = save->vertex_size;
- node->buffer_offset =
- (save->buffer_map - save->vertex_store->buffer_map) * sizeof(GLfloat);
+ GLintptr old_offset = 0;
+ if (save->VAO[0]) {
+ old_offset = save->VAO[0]->BufferBinding[0].Offset
+ + save->VAO[0]->VertexAttrib[VERT_ATTRIB_POS].RelativeOffset;
+ }
+ const GLsizei stride = save->vertex_size*sizeof(GLfloat);
+ GLintptr buffer_offset =
+ (save->buffer_map - save->vertex_store->buffer_map) * sizeof(GLfloat);
+ assert(old_offset <= buffer_offset);
+ const GLintptr offset_diff = buffer_offset - old_offset;
+ GLuint start_offset = 0;
+ if (offset_diff > 0 && stride > 0 && offset_diff % stride == 0) {
+ /* The vertex size is an exact multiple of the buffer offset.
+ * This means that we can use zero-based vertex attribute pointers
+ * and specify the start of the primitive with the _mesa_prim::start
+ * field. This results in issuing several draw calls with identical
+ * vertex attribute information. This can result in fewer state
+ * changes in drivers. In particular, the Gallium CSO module will
+ * filter out redundant vertex buffer changes.
+ */
+ /* We cannot immediately update the primitives as some methods below
+ * still need the uncorrected start vertices
+ */
+ start_offset = offset_diff/stride;
+ assert(old_offset == buffer_offset - offset_diff);
+ buffer_offset = old_offset;
+ }
+ GLuint offsets[VBO_ATTRIB_MAX];
+ for (unsigned i = 0, offset = 0; i < VBO_ATTRIB_MAX; ++i) {
+ offsets[i] = offset;
+ offset += save->attrsz[i] * sizeof(GLfloat);
+ }
node->vertex_count = save->vert_count;
node->wrap_count = save->copied.nr;
- node->dangling_attr_ref = save->dangling_attr_ref;
node->prims = save->prims;
node->prim_count = save->prim_count;
- node->vertex_store = save->vertex_store;
node->prim_store = save->prim_store;
- node->vertex_store->refcount++;
+ /* Create a pair of VAOs for the possible VERTEX_PROCESSING_MODEs
+ * Note that this may reuse the previous one of possible.
+ */
+ for (gl_vertex_processing_mode vpm = VP_MODE_FF; vpm < VP_MODE_MAX; ++vpm) {
+ /* create or reuse the vao */
+ update_vao(ctx, vpm, &save->VAO[vpm],
+ save->vertex_store->bufferobj, buffer_offset, stride,
+ save->enabled, save->attrsz, save->attrtype, offsets);
+ /* Reference the vao in the dlist */
+ node->VAO[vpm] = NULL;
+ _mesa_reference_vao(ctx, &node->VAO[vpm], save->VAO[vpm]);
+ }
+
node->prim_store->refcount++;
- if (node->prims[0].no_current_update) {
- node->current_size = 0;
+ if (save->no_current_update) {
node->current_data = NULL;
}
else {
- node->current_size = node->vertex_size - node->attrsz[0];
+ GLuint current_size = save->vertex_size - save->attrsz[0];
node->current_data = NULL;
- if (node->current_size) {
- /* If the malloc fails, we just pull the data out of the VBO
- * later instead.
- */
- node->current_data = malloc(node->current_size * sizeof(GLfloat));
+ if (current_size) {
+ node->current_data = malloc(current_size * sizeof(GLfloat));
if (node->current_data) {
- const char *buffer = (const char *) save->vertex_store->buffer_map;
- unsigned attr_offset = node->attrsz[0] * sizeof(GLfloat);
+ const char *buffer = (const char *)save->buffer_map;
+ unsigned attr_offset = save->attrsz[0] * sizeof(GLfloat);
unsigned vertex_offset = 0;
if (node->vertex_count)
- vertex_offset =
- (node->vertex_count - 1) * node->vertex_size * sizeof(GLfloat);
+ vertex_offset = (node->vertex_count - 1) * stride;
- memcpy(node->current_data,
- buffer + node->buffer_offset + vertex_offset + attr_offset,
- node->current_size * sizeof(GLfloat));
+ memcpy(node->current_data, buffer + vertex_offset + attr_offset,
+ current_size * sizeof(GLfloat));
+ } else {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "Current value allocation");
}
}
}
- assert(node->attrsz[VBO_ATTRIB_POS] != 0 || node->vertex_count == 0);
+ assert(save->attrsz[VBO_ATTRIB_POS] != 0 || node->vertex_count == 0);
if (save->dangling_attr_ref)
ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;
convert_line_loop_to_strip(save, node);
}
- merge_prims(node->prims, &node->prim_count);
+ merge_prims(ctx, node->prims, &node->prim_count);
+
+ /* Correct the primitive starts, we can only do this here as copy_vertices
+ * and convert_line_loop_to_strip above consume the uncorrected starts.
+ * On the other hand the _vbo_loopback_vertex_list call below needs the
+ * primitves to be corrected already.
+ */
+ for (unsigned i = 0; i < node->prim_count; i++) {
+ node->prims[i].start += start_offset;
+ }
/* Deal with GL_COMPILE_AND_EXECUTE:
*/
_glapi_set_dispatch(ctx->Exec);
- const GLfloat *buffer = (const GLfloat *)
- ((const char *) save->vertex_store->buffer_map +
- node->buffer_offset);
-
- vbo_loopback_vertex_list(ctx, buffer,
- node->attrsz, node->prims, node->prim_count,
- node->wrap_count, node->vertex_size);
+ /* Note that the range of referenced vertices must be mapped already */
+ _vbo_loopback_vertex_list(ctx, node);
_glapi_set_dispatch(dispatch);
}
/* Release old reference:
*/
- save->vertex_store->refcount--;
- assert(save->vertex_store->refcount != 0);
+ free_vertex_store(ctx, save->vertex_store);
save->vertex_store = NULL;
+ /* When we have a new vbo, we will for sure need a new vao */
+ for (gl_vertex_processing_mode vpm = 0; vpm < VP_MODE_MAX; ++vpm)
+ _mesa_reference_vao(ctx, &save->VAO[vpm], NULL);
/* Allocate and map new store:
*/
save->prim_store = alloc_prim_store();
}
- /*
- * If the vertex buffer offset is a multiple of the vertex size,
- * we can use the _mesa_prim::start value to indicate where the
- * vertices starts, instead of the buffer offset. Also see the
- * bind_vertex_list() function.
- */
- if (aligned_vertex_buffer_offset(node)) {
- const unsigned start_offset =
- node->buffer_offset / (node->vertex_size * sizeof(GLfloat));
- for (unsigned i = 0; i < save->prim_count; i++) {
- save->prims[i].start += start_offset;
- }
- }
-
/* Reset our structures for the next run of vertices:
*/
reset_counters(ctx);
struct vbo_save_context *save = &vbo_context(ctx)->save;
GLint i = save->prim_count - 1;
GLenum mode;
- GLboolean weak;
- GLboolean no_current_update;
assert(i < (GLint) save->prim_max);
assert(i >= 0);
*/
save->prims[i].count = (save->vert_count - save->prims[i].start);
mode = save->prims[i].mode;
- weak = save->prims[i].weak;
- no_current_update = save->prims[i].no_current_update;
/* store the copied vertices, and allocate a new list.
*/
/* Restart interrupted primitive
*/
save->prims[0].mode = mode;
- save->prims[0].weak = weak;
- save->prims[0].no_current_update = no_current_update;
save->prims[0].begin = 0;
save->prims[0].end = 0;
- save->prims[0].pad = 0;
save->prims[0].start = 0;
save->prims[0].count = 0;
- save->prims[0].num_instances = 1;
- save->prims[0].base_instance = 0;
- save->prims[0].is_indirect = 0;
save->prim_count = 1;
}
const int i = u_bit_scan64(&enabled);
assert(save->attrsz[i]);
- save->currentsz[i][0] = save->attrsz[i];
- COPY_CLEAN_4V_TYPE_AS_UNION(save->current[i], save->attrsz[i],
- save->attrptr[i], save->attrtype[i]);
+ if (save->attrtype[i] == GL_DOUBLE ||
+ save->attrtype[i] == GL_UNSIGNED_INT64_ARB)
+ memcpy(save->current[i], save->attrptr[i], save->attrsz[i] * sizeof(GLfloat));
+ else
+ COPY_CLEAN_4V_TYPE_AS_UNION(save->current[i], save->attrsz[i],
+ save->attrptr[i], save->attrtype[i]);
}
}
switch (save->attrsz[i]) {
case 4:
save->attrptr[i][3] = save->current[i][3];
+ /* fallthrough */
case 3:
save->attrptr[i][2] = save->current[i][2];
+ /* fallthrough */
case 2:
save->attrptr[i][1] = save->current[i][1];
+ /* fallthrough */
case 1:
save->attrptr[i][0] = save->current[i][0];
break;
* get a glTexCoord4f() or glTexCoord1f() call.
*/
static void
-fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint sz)
+fixup_vertex(struct gl_context *ctx, GLuint attr,
+ GLuint sz, GLenum newType)
{
struct vbo_save_context *save = &vbo_context(ctx)->save;
- if (sz > save->attrsz[attr]) {
+ if (sz > save->attrsz[attr] ||
+ newType != save->attrtype[attr]) {
/* New size is larger. Need to flush existing vertices and get
* an enlarged vertex format.
*/
}
+/**
+ * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
+ * It depends on a few things, including whether we're inside or outside
+ * of glBegin/glEnd.
+ */
+static inline bool
+is_vertex_position(const struct gl_context *ctx, GLuint index)
+{
+ return (index == 0 &&
+ _mesa_attr_zero_aliases_vertex(ctx) &&
+ _mesa_inside_dlist_begin_end(ctx));
+}
+
+
#define ERROR(err) _mesa_compile_error(ctx, err, __func__);
#define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
do { \
struct vbo_save_context *save = &vbo_context(ctx)->save; \
+ int sz = (sizeof(C) / sizeof(GLfloat)); \
\
if (save->active_sz[A] != N) \
- fixup_vertex(ctx, A, N); \
+ fixup_vertex(ctx, A, N * sz, T); \
\
{ \
C *dest = (C *)save->attrptr[A]; \
* Updating of ctx->Driver.CurrentSavePrimitive is already taken care of.
*/
void
-vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode)
+vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode,
+ bool no_current_update)
{
struct vbo_save_context *save = &vbo_context(ctx)->save;
const GLuint i = save->prim_count++;
+ ctx->Driver.CurrentSavePrimitive = mode;
+
assert(i < save->prim_max);
save->prims[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;
save->prims[i].begin = 1;
save->prims[i].end = 0;
- save->prims[i].weak = (mode & VBO_SAVE_PRIM_WEAK) ? 1 : 0;
- save->prims[i].no_current_update =
- (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;
- save->prims[i].pad = 0;
save->prims[i].start = save->vert_count;
save->prims[i].count = 0;
- save->prims[i].num_instances = 1;
- save->prims[i].base_instance = 0;
- save->prims[i].is_indirect = 0;
+
+ save->no_current_update = no_current_update;
if (save->out_of_memory) {
_mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
} else {
/* get current primitive mode */
GLenum curPrim = save->prims[save->prim_count - 1].mode;
+ bool no_current_update = save->no_current_update;
/* restart primitive */
CALL_End(GET_DISPATCH(), ());
- vbo_save_NotifyBegin(ctx, curPrim);
+ vbo_save_NotifyBegin(ctx, curPrim, no_current_update);
}
}
_save_OBE_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
GET_CURRENT_CONTEXT(ctx);
- vbo_save_NotifyBegin(ctx, GL_QUADS | VBO_SAVE_PRIM_WEAK);
+ vbo_save_NotifyBegin(ctx, GL_QUADS, false);
CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
_save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
{
GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object *vao = ctx->Array.VAO;
struct vbo_save_context *save = &vbo_context(ctx)->save;
GLint i;
/* Make sure to process any VBO binding changes */
_mesa_update_state(ctx);
- _ae_map_vbos(ctx);
+ _mesa_vao_map_arrays(ctx, vao, GL_MAP_READ_BIT);
- vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK
- | VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
+ vbo_save_NotifyBegin(ctx, mode, true);
for (i = 0; i < count; i++)
- CALL_ArrayElement(GET_DISPATCH(), (start + i));
+ _mesa_array_element(ctx, start + i);
CALL_End(GET_DISPATCH(), ());
- _ae_unmap_vbos(ctx);
+ _mesa_vao_unmap_arrays(ctx, vao);
}
}
+static void
+array_element(struct gl_context *ctx,
+ GLint basevertex, GLuint elt, unsigned index_size)
+{
+ /* Section 10.3.5 Primitive Restart:
+ * [...]
+ * When one of the *BaseVertex drawing commands specified in section 10.5
+ * is used, the primitive restart comparison occurs before the basevertex
+ * offset is added to the array index.
+ */
+ /* If PrimitiveRestart is enabled and the index is the RestartIndex
+ * then we call PrimitiveRestartNV and return.
+ */
+ if (ctx->Array._PrimitiveRestart &&
+ elt == ctx->Array._RestartIndex[index_size - 1]) {
+ CALL_PrimitiveRestartNV(GET_DISPATCH(), ());
+ return;
+ }
+
+ _mesa_array_element(ctx, basevertex + elt);
+}
+
+
/* Could do better by copying the arrays and element list intact and
* then emitting an indexed prim at runtime.
*/
{
GET_CURRENT_CONTEXT(ctx);
struct vbo_save_context *save = &vbo_context(ctx)->save;
- struct gl_buffer_object *indexbuf = ctx->Array.VAO->IndexBufferObj;
+ struct gl_vertex_array_object *vao = ctx->Array.VAO;
+ struct gl_buffer_object *indexbuf = vao->IndexBufferObj;
GLint i;
if (!_mesa_is_valid_prim_mode(ctx, mode)) {
/* Make sure to process any VBO binding changes */
_mesa_update_state(ctx);
- _ae_map_vbos(ctx);
+ _mesa_vao_map(ctx, vao, GL_MAP_READ_BIT);
- if (_mesa_is_bufferobj(indexbuf))
+ if (indexbuf)
indices =
ADD_POINTERS(indexbuf->Mappings[MAP_INTERNAL].Pointer, indices);
- vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK |
- VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
+ vbo_save_NotifyBegin(ctx, mode, true);
switch (type) {
case GL_UNSIGNED_BYTE:
for (i = 0; i < count; i++)
- CALL_ArrayElement(GET_DISPATCH(), (basevertex + ((GLubyte *) indices)[i]));
+ array_element(ctx, basevertex, ((GLubyte *) indices)[i], 1);
break;
case GL_UNSIGNED_SHORT:
for (i = 0; i < count; i++)
- CALL_ArrayElement(GET_DISPATCH(), (basevertex + ((GLushort *) indices)[i]));
+ array_element(ctx, basevertex, ((GLushort *) indices)[i], 2);
break;
case GL_UNSIGNED_INT:
for (i = 0; i < count; i++)
- CALL_ArrayElement(GET_DISPATCH(), (basevertex + ((GLuint *) indices)[i]));
+ array_element(ctx, basevertex, ((GLuint *) indices)[i], 4);
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)");
CALL_End(GET_DISPATCH(), ());
- _ae_unmap_vbos(ctx);
+ _mesa_vao_unmap(ctx, vao);
}
static void GLAPIENTRY
struct vbo_save_context *save = &vbo_context(ctx)->save;
GLvertexformat *vfmt = &save->vtxfmt;
- vfmt->ArrayElement = _ae_ArrayElement;
-
- vfmt->Color3f = _save_Color3f;
- vfmt->Color3fv = _save_Color3fv;
- vfmt->Color4f = _save_Color4f;
- vfmt->Color4fv = _save_Color4fv;
- vfmt->EdgeFlag = _save_EdgeFlag;
- vfmt->End = _save_End;
- vfmt->PrimitiveRestartNV = _save_PrimitiveRestartNV;
- vfmt->FogCoordfEXT = _save_FogCoordfEXT;
- vfmt->FogCoordfvEXT = _save_FogCoordfvEXT;
- vfmt->Indexf = _save_Indexf;
- vfmt->Indexfv = _save_Indexfv;
- vfmt->Materialfv = _save_Materialfv;
- vfmt->MultiTexCoord1fARB = _save_MultiTexCoord1f;
- vfmt->MultiTexCoord1fvARB = _save_MultiTexCoord1fv;
- vfmt->MultiTexCoord2fARB = _save_MultiTexCoord2f;
- vfmt->MultiTexCoord2fvARB = _save_MultiTexCoord2fv;
- vfmt->MultiTexCoord3fARB = _save_MultiTexCoord3f;
- vfmt->MultiTexCoord3fvARB = _save_MultiTexCoord3fv;
- vfmt->MultiTexCoord4fARB = _save_MultiTexCoord4f;
- vfmt->MultiTexCoord4fvARB = _save_MultiTexCoord4fv;
- vfmt->Normal3f = _save_Normal3f;
- vfmt->Normal3fv = _save_Normal3fv;
- vfmt->SecondaryColor3fEXT = _save_SecondaryColor3fEXT;
- vfmt->SecondaryColor3fvEXT = _save_SecondaryColor3fvEXT;
- vfmt->TexCoord1f = _save_TexCoord1f;
- vfmt->TexCoord1fv = _save_TexCoord1fv;
- vfmt->TexCoord2f = _save_TexCoord2f;
- vfmt->TexCoord2fv = _save_TexCoord2fv;
- vfmt->TexCoord3f = _save_TexCoord3f;
- vfmt->TexCoord3fv = _save_TexCoord3fv;
- vfmt->TexCoord4f = _save_TexCoord4f;
- vfmt->TexCoord4fv = _save_TexCoord4fv;
- vfmt->Vertex2f = _save_Vertex2f;
- vfmt->Vertex2fv = _save_Vertex2fv;
- vfmt->Vertex3f = _save_Vertex3f;
- vfmt->Vertex3fv = _save_Vertex3fv;
- vfmt->Vertex4f = _save_Vertex4f;
- vfmt->Vertex4fv = _save_Vertex4fv;
- vfmt->VertexAttrib1fARB = _save_VertexAttrib1fARB;
- vfmt->VertexAttrib1fvARB = _save_VertexAttrib1fvARB;
- vfmt->VertexAttrib2fARB = _save_VertexAttrib2fARB;
- vfmt->VertexAttrib2fvARB = _save_VertexAttrib2fvARB;
- vfmt->VertexAttrib3fARB = _save_VertexAttrib3fARB;
- vfmt->VertexAttrib3fvARB = _save_VertexAttrib3fvARB;
- vfmt->VertexAttrib4fARB = _save_VertexAttrib4fARB;
- vfmt->VertexAttrib4fvARB = _save_VertexAttrib4fvARB;
-
- vfmt->VertexAttrib1fNV = _save_VertexAttrib1fNV;
- vfmt->VertexAttrib1fvNV = _save_VertexAttrib1fvNV;
- vfmt->VertexAttrib2fNV = _save_VertexAttrib2fNV;
- vfmt->VertexAttrib2fvNV = _save_VertexAttrib2fvNV;
- vfmt->VertexAttrib3fNV = _save_VertexAttrib3fNV;
- vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV;
- vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV;
- vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV;
-
- /* integer-valued */
- vfmt->VertexAttribI1i = _save_VertexAttribI1i;
- vfmt->VertexAttribI2i = _save_VertexAttribI2i;
- vfmt->VertexAttribI3i = _save_VertexAttribI3i;
- vfmt->VertexAttribI4i = _save_VertexAttribI4i;
- vfmt->VertexAttribI2iv = _save_VertexAttribI2iv;
- vfmt->VertexAttribI3iv = _save_VertexAttribI3iv;
- vfmt->VertexAttribI4iv = _save_VertexAttribI4iv;
-
- /* unsigned integer-valued */
- vfmt->VertexAttribI1ui = _save_VertexAttribI1ui;
- vfmt->VertexAttribI2ui = _save_VertexAttribI2ui;
- vfmt->VertexAttribI3ui = _save_VertexAttribI3ui;
- vfmt->VertexAttribI4ui = _save_VertexAttribI4ui;
- vfmt->VertexAttribI2uiv = _save_VertexAttribI2uiv;
- vfmt->VertexAttribI3uiv = _save_VertexAttribI3uiv;
- vfmt->VertexAttribI4uiv = _save_VertexAttribI4uiv;
-
- vfmt->VertexP2ui = _save_VertexP2ui;
- vfmt->VertexP3ui = _save_VertexP3ui;
- vfmt->VertexP4ui = _save_VertexP4ui;
- vfmt->VertexP2uiv = _save_VertexP2uiv;
- vfmt->VertexP3uiv = _save_VertexP3uiv;
- vfmt->VertexP4uiv = _save_VertexP4uiv;
-
- vfmt->TexCoordP1ui = _save_TexCoordP1ui;
- vfmt->TexCoordP2ui = _save_TexCoordP2ui;
- vfmt->TexCoordP3ui = _save_TexCoordP3ui;
- vfmt->TexCoordP4ui = _save_TexCoordP4ui;
- vfmt->TexCoordP1uiv = _save_TexCoordP1uiv;
- vfmt->TexCoordP2uiv = _save_TexCoordP2uiv;
- vfmt->TexCoordP3uiv = _save_TexCoordP3uiv;
- vfmt->TexCoordP4uiv = _save_TexCoordP4uiv;
-
- vfmt->MultiTexCoordP1ui = _save_MultiTexCoordP1ui;
- vfmt->MultiTexCoordP2ui = _save_MultiTexCoordP2ui;
- vfmt->MultiTexCoordP3ui = _save_MultiTexCoordP3ui;
- vfmt->MultiTexCoordP4ui = _save_MultiTexCoordP4ui;
- vfmt->MultiTexCoordP1uiv = _save_MultiTexCoordP1uiv;
- vfmt->MultiTexCoordP2uiv = _save_MultiTexCoordP2uiv;
- vfmt->MultiTexCoordP3uiv = _save_MultiTexCoordP3uiv;
- vfmt->MultiTexCoordP4uiv = _save_MultiTexCoordP4uiv;
-
- vfmt->NormalP3ui = _save_NormalP3ui;
- vfmt->NormalP3uiv = _save_NormalP3uiv;
-
- vfmt->ColorP3ui = _save_ColorP3ui;
- vfmt->ColorP4ui = _save_ColorP4ui;
- vfmt->ColorP3uiv = _save_ColorP3uiv;
- vfmt->ColorP4uiv = _save_ColorP4uiv;
-
- vfmt->SecondaryColorP3ui = _save_SecondaryColorP3ui;
- vfmt->SecondaryColorP3uiv = _save_SecondaryColorP3uiv;
-
- vfmt->VertexAttribP1ui = _save_VertexAttribP1ui;
- vfmt->VertexAttribP2ui = _save_VertexAttribP2ui;
- vfmt->VertexAttribP3ui = _save_VertexAttribP3ui;
- vfmt->VertexAttribP4ui = _save_VertexAttribP4ui;
-
- vfmt->VertexAttribP1uiv = _save_VertexAttribP1uiv;
- vfmt->VertexAttribP2uiv = _save_VertexAttribP2uiv;
- vfmt->VertexAttribP3uiv = _save_VertexAttribP3uiv;
- vfmt->VertexAttribP4uiv = _save_VertexAttribP4uiv;
-
- vfmt->VertexAttribL1d = _save_VertexAttribL1d;
- vfmt->VertexAttribL2d = _save_VertexAttribL2d;
- vfmt->VertexAttribL3d = _save_VertexAttribL3d;
- vfmt->VertexAttribL4d = _save_VertexAttribL4d;
-
- vfmt->VertexAttribL1dv = _save_VertexAttribL1dv;
- vfmt->VertexAttribL2dv = _save_VertexAttribL2dv;
- vfmt->VertexAttribL3dv = _save_VertexAttribL3dv;
- vfmt->VertexAttribL4dv = _save_VertexAttribL4dv;
-
- vfmt->VertexAttribL1ui64ARB = _save_VertexAttribL1ui64ARB;
- vfmt->VertexAttribL1ui64vARB = _save_VertexAttribL1ui64vARB;
-
- /* This will all require us to fallback to saving the list as opcodes:
- */
- vfmt->CallList = _save_CallList;
- vfmt->CallLists = _save_CallLists;
-
- vfmt->EvalCoord1f = _save_EvalCoord1f;
- vfmt->EvalCoord1fv = _save_EvalCoord1fv;
- vfmt->EvalCoord2f = _save_EvalCoord2f;
- vfmt->EvalCoord2fv = _save_EvalCoord2fv;
- vfmt->EvalPoint1 = _save_EvalPoint1;
- vfmt->EvalPoint2 = _save_EvalPoint2;
-
- /* These calls all generate GL_INVALID_OPERATION since this vtxfmt is
- * only used when we're inside a glBegin/End pair.
- */
- vfmt->Begin = _save_Begin;
+#define NAME_AE(x) _ae_##x
+#define NAME_CALLLIST(x) _save_##x
+#define NAME(x) _save_##x
+#define NAME_ES(x) _save_##x##ARB
+
+#include "vbo_init_tmp.h"
}
{
struct vbo_save_context *save = &vbo_context(ctx)->save;
- if (ctx->ListState.CallDepth == 1) {
- /* This is correct: want to keep only the VBO_SAVE_FALLBACK
- * flag, if it is set:
- */
- save->replay_flags &= VBO_SAVE_FALLBACK;
- }
+ if (ctx->ListState.CallDepth == 1)
+ save->replay_flags = 0;
}
vbo_destroy_vertex_list(struct gl_context *ctx, void *data)
{
struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
- (void) ctx;
- if (--node->vertex_store->refcount == 0)
- free_vertex_store(ctx, node->vertex_store);
+ for (gl_vertex_processing_mode vpm = VP_MODE_FF; vpm < VP_MODE_MAX; ++vpm)
+ _mesa_reference_vao(ctx, &node->VAO[vpm], NULL);
if (--node->prim_store->refcount == 0)
free(node->prim_store);
{
struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
GLuint i;
- struct gl_buffer_object *buffer = node->vertex_store ?
- node->vertex_store->bufferobj : NULL;
+ struct gl_buffer_object *buffer = node->VAO[0]->BufferBinding[0].BufferObj;
+ const GLuint vertex_size = _vbo_save_get_stride(node)/sizeof(GLfloat);
(void) ctx;
fprintf(f, "VBO-VERTEX-LIST, %u vertices, %d primitives, %d vertsize, "
"buffer %p\n",
- node->vertex_count, node->prim_count, node->vertex_size,
+ node->vertex_count, node->prim_count, vertex_size,
buffer);
for (i = 0; i < node->prim_count; i++) {
struct _mesa_prim *prim = &node->prims[i];
- fprintf(f, " prim %d: %s%s %d..%d %s %s\n",
+ fprintf(f, " prim %d: %s %d..%d %s %s\n",
i,
_mesa_lookup_prim_by_nr(prim->mode),
- prim->weak ? " (weak)" : "",
prim->start,
prim->start + prim->count,
(prim->begin) ? "BEGIN" : "(wrap)",
vbo_save_api_init(struct vbo_save_context *save)
{
struct gl_context *ctx = save->ctx;
- GLuint i;
save->opcode_vertex_list =
_mesa_dlist_alloc_opcode(ctx,
vtxfmt_init(ctx);
current_init(ctx);
- _mesa_noop_vtxfmt_init(&save->vtxfmt_noop);
-
- /* These will actually get set again when binding/drawing */
- for (i = 0; i < VBO_ATTRIB_MAX; i++)
- save->inputs[i] = &save->arrays[i];
+ _mesa_noop_vtxfmt_init(ctx, &save->vtxfmt_noop);
}
projects / mesa.git / blobdiff