#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"
_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);
+ _mesa_bind_vertex_buffer(ctx, *vao, 0, bo, buffer_offset, stride);
/* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space
* Note that the position/generic0 aliasing is done in the VAO.
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, false);
- _mesa_enable_vertex_array_attrib(ctx, *vao, vao_attr, false);
+ _mesa_vertex_attrib_binding(ctx, *vao, vao_attr, 0);
+ _mesa_enable_vertex_array_attrib(ctx, *vao, vao_attr);
}
assert(vao_enabled == (*vao)->_Enabled);
assert((vao_enabled & ~(*vao)->VertexAttribBufferMask) == 0);
{
struct vbo_save_context *save = &vbo_context(ctx)->save;
struct vbo_save_vertex_list *node;
- GLintptr buffer_offset = 0;
/* Allocate space for this structure in the display list currently
* being compiled.
/* Duplicate our template, increment refcounts to the storage structs:
*/
- STATIC_ASSERT(sizeof(node->attrsz) == sizeof(save->attrsz));
- memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));
- STATIC_ASSERT(sizeof(node->attrtype) == sizeof(save->attrtype));
- 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);
- if (aligned_vertex_buffer_offset(node)) {
+ 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
* changes in drivers. In particular, the Gallium CSO module will
* filter out redundant vertex buffer changes.
*/
- buffer_offset = 0;
- } else {
- buffer_offset = node->buffer_offset;
+ /* 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) {
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,
- node->vertex_size*sizeof(GLfloat), save->enabled,
- node->attrsz, node->attrtype, offsets);
+ 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) {
+ if (save->no_current_update) {
node->current_data = NULL;
}
else {
- GLuint current_size = node->vertex_size - node->attrsz[0];
+ GLuint current_size = save->vertex_size - save->attrsz[0];
node->current_data = NULL;
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,
+ 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;
* On the other hand the _vbo_loopback_vertex_list call below needs the
* primitves to be corrected already.
*/
- if (aligned_vertex_buffer_offset(node)) {
- const unsigned start_offset =
- node->buffer_offset / (node->vertex_size * sizeof(GLfloat));
- for (unsigned i = 0; i < node->prim_count; i++) {
- node->prims[i].start += start_offset;
- }
- node->start_vertex = start_offset;
- } else {
- node->start_vertex = 0;
+ for (unsigned i = 0; i < node->prim_count; i++) {
+ node->prims[i].start += start_offset;
}
/* Deal with GL_COMPILE_AND_EXECUTE:
*/
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:
*/
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;
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]);
}
}
* 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.
*/
#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++;
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].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));
_ae_map_vbos(ctx);
- 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));
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:
{
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;
}
struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
GLuint i;
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)",
projects / mesa.git / blobdiff