X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fvbo%2Fvbo_exec_api.c;h=881255ceb729a898c784bea73b9cd632f951341f;hb=b9280031a8f970ebec03edc9954d7d3ade54ba42;hp=e02bb907c4fca6f318acef6317b672f7744be512;hpb=bc4e0c486874ee8c6f2e616b91589a1da63164d8;p=mesa.git diff --git a/src/mesa/vbo/vbo_exec_api.c b/src/mesa/vbo/vbo_exec_api.c index e02bb907c4f..881255ceb72 100644 --- a/src/mesa/vbo/vbo_exec_api.c +++ b/src/mesa/vbo/vbo_exec_api.c @@ -44,20 +44,16 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "main/dispatch.h" #include "util/bitscan.h" -#include "vbo_context.h" #include "vbo_noop.h" - - -#ifdef ERROR -#undef ERROR -#endif +#include "vbo_private.h" /** ID/name for immediate-mode VBO */ #define IMM_BUFFER_NAME 0xaabbccdd -static void reset_attrfv( struct vbo_exec_context *exec ); +static void +vbo_reset_all_attr(struct vbo_exec_context *exec); /** @@ -65,7 +61,8 @@ static void reset_attrfv( struct vbo_exec_context *exec ); * primitive. This is called when we fill a vertex buffer before * hitting glEnd. */ -static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec ) +static void +vbo_exec_wrap_buffers(struct vbo_exec_context *exec) { if (exec->vtx.prim_count == 0) { exec->vtx.copied.nr = 0; @@ -78,7 +75,7 @@ static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec ) GLuint last_count; if (_mesa_inside_begin_end(exec->ctx)) { - last_prim->count = exec->vtx.vert_count - last_prim->start; + last_prim->count = exec->vtx.vert_count - last_prim->start; } last_count = last_prim->count; @@ -102,10 +99,10 @@ static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec ) /* Execute the buffer and save copied vertices. */ if (exec->vtx.vert_count) - vbo_exec_vtx_flush( exec, GL_FALSE ); + vbo_exec_vtx_flush(exec, GL_FALSE); else { - exec->vtx.prim_count = 0; - exec->vtx.copied.nr = 0; + exec->vtx.prim_count = 0; + exec->vtx.copied.nr = 0; } /* Emit a glBegin to start the new list. @@ -113,15 +110,15 @@ static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec ) assert(exec->vtx.prim_count == 0); if (_mesa_inside_begin_end(exec->ctx)) { - exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive; - exec->vtx.prim[0].begin = 0; + exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive; + exec->vtx.prim[0].begin = 0; exec->vtx.prim[0].end = 0; - exec->vtx.prim[0].start = 0; - exec->vtx.prim[0].count = 0; - exec->vtx.prim_count++; - - if (exec->vtx.copied.nr == last_count) - exec->vtx.prim[0].begin = last_begin; + exec->vtx.prim[0].start = 0; + exec->vtx.prim[0].count = 0; + exec->vtx.prim_count++; + + if (exec->vtx.copied.nr == last_count) + exec->vtx.prim[0].begin = last_begin; } } } @@ -139,14 +136,14 @@ vbo_exec_vtx_wrap(struct vbo_exec_context *exec) /* Run pipeline on current vertices, copy wrapped vertices * to exec->vtx.copied. */ - vbo_exec_wrap_buffers( exec ); - + vbo_exec_wrap_buffers(exec); + if (!exec->vtx.buffer_ptr) { /* probably ran out of memory earlier when allocating the VBO */ return; } - /* Copy stored stored vertices to start of new list. + /* Copy stored stored vertices to start of new list. */ assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr); @@ -164,7 +161,8 @@ vbo_exec_vtx_wrap(struct vbo_exec_context *exec) /** * Copy the active vertex's values to the ctx->Current fields. */ -static void vbo_exec_copy_to_current( struct vbo_exec_context *exec ) +static void +vbo_exec_copy_to_current(struct vbo_exec_context *exec) { struct gl_context *ctx = exec->ctx; struct vbo_context *vbo = vbo_context(ctx); @@ -178,11 +176,16 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec ) */ GLfloat *current = (GLfloat *)vbo->currval[i].Ptr; fi_type tmp[8]; /* space for doubles */ - int dmul = exec->vtx.attrtype[i] == GL_DOUBLE ? 2 : 1; + int dmul = 1; + + if (exec->vtx.attrtype[i] == GL_DOUBLE || + exec->vtx.attrtype[i] == GL_UNSIGNED_INT64_ARB) + dmul = 2; assert(exec->vtx.attrsz[i]); - if (exec->vtx.attrtype[i] == GL_DOUBLE) { + if (exec->vtx.attrtype[i] == GL_DOUBLE || + exec->vtx.attrtype[i] == GL_UNSIGNED_INT64_ARB) { memset(tmp, 0, sizeof(tmp)); memcpy(tmp, exec->vtx.attrptr[i], exec->vtx.attrsz[i] * sizeof(GLfloat)); } else { @@ -195,7 +198,7 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec ) if (exec->vtx.attrtype[i] != vbo->currval[i].Type || memcmp(current, tmp, 4 * sizeof(GLfloat) * dmul) != 0) { memcpy(current, tmp, 4 * sizeof(GLfloat) * dmul); - + /* Given that we explicitly state size here, there is no need * for the COPY_CLEAN above, could just copy 16 bytes and be * done. The only problem is when Mesa accesses ctx->Current @@ -203,7 +206,8 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec ) */ /* Size here is in components - not bytes */ vbo->currval[i].Size = exec->vtx.attrsz[i] / dmul; - vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat) * dmul; + vbo->currval[i]._ElementSize = + vbo->currval[i].Size * sizeof(GLfloat) * dmul; vbo->currval[i].Type = exec->vtx.attrtype[i]; vbo->currval[i].Integer = vbo_attrtype_to_integer_flag(exec->vtx.attrtype[i]); @@ -225,8 +229,8 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec ) */ if (ctx->Light.ColorMaterialEnabled && exec->vtx.attrsz[VBO_ATTRIB_COLOR0]) { - _mesa_update_color_material(ctx, - ctx->Current.Attrib[VBO_ATTRIB_COLOR0]); + _mesa_update_color_material(ctx, + ctx->Current.Attrib[VBO_ATTRIB_COLOR0]); } } @@ -242,8 +246,10 @@ vbo_exec_copy_from_current(struct vbo_exec_context *exec) GLint i; for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) { - if (exec->vtx.attrtype[i] == GL_DOUBLE) { - memcpy(exec->vtx.attrptr[i], vbo->currval[i].Ptr, exec->vtx.attrsz[i] * sizeof(GLfloat)); + if (exec->vtx.attrtype[i] == GL_DOUBLE || + exec->vtx.attrtype[i] == GL_UNSIGNED_INT64_ARB) { + memcpy(exec->vtx.attrptr[i], vbo->currval[i].Ptr, + exec->vtx.attrsz[i] * sizeof(GLfloat)); } else { const fi_type *current = (fi_type *) vbo->currval[i].Ptr; switch (exec->vtx.attrsz[i]) { @@ -264,10 +270,11 @@ vbo_exec_copy_from_current(struct vbo_exec_context *exec) * to a larger one. Ex: glTexCoord2f -> glTexCoord4f. * We need to go back over the previous 2-component texcoords and insert * zero and one values. - */ + * \param attr VBO_ATTRIB_x vertex attribute value + */ static void vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, - GLuint attr, GLuint newSize ) + GLuint attr, GLuint newSize) { struct gl_context *ctx = exec->ctx; struct vbo_context *vbo = vbo_context(ctx); @@ -277,10 +284,12 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, const GLuint oldSize = exec->vtx.attrsz[attr]; GLuint i; + assert(attr < VBO_ATTRIB_MAX); + /* Run pipeline on current vertices, copy wrapped vertices * to exec->vtx.copied. */ - vbo_exec_wrap_buffers( exec ); + vbo_exec_wrap_buffers(exec); if (unlikely(exec->vtx.copied.nr)) { /* We're in the middle of a primitive, keep the old vertex @@ -295,7 +304,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, * case when the attribute already exists in the vertex and is * having its size increased. */ - vbo_exec_copy_to_current( exec ); + vbo_exec_copy_to_current(exec); } /* Heuristic: Attempt to isolate attributes received outside @@ -303,8 +312,8 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, */ if (!_mesa_inside_begin_end(ctx) && !oldSize && lastcount > 8 && exec->vtx.vertex_size) { - vbo_exec_copy_to_current( exec ); - reset_attrfv( exec ); + vbo_exec_copy_to_current(exec); + vbo_reset_all_attr(exec); } /* Fix up sizes: @@ -322,18 +331,18 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, fi_type *tmp = exec->vtx.vertex; for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) { - if (exec->vtx.attrsz[i]) { - exec->vtx.attrptr[i] = tmp; - tmp += exec->vtx.attrsz[i]; - } - else - exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */ + if (exec->vtx.attrsz[i]) { + exec->vtx.attrptr[i] = tmp; + tmp += exec->vtx.attrsz[i]; + } + else + exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */ } /* Copy from current to repopulate the vertex with correct * values. */ - vbo_exec_copy_from_current( exec ); + vbo_exec_copy_from_current(exec); } else { /* Just have to append the new attribute at the end */ @@ -356,7 +365,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, GLbitfield64 enabled = exec->vtx.enabled; while (enabled) { const int j = u_bit_scan64(&enabled); - GLuint sz = exec->vtx.attrsz[j]; + GLuint sz = exec->vtx.attrsz[j]; GLint old_offset = old_attrptr[j] - exec->vtx.vertex; GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex; @@ -377,10 +386,10 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, else { COPY_SZ_4V(dest + new_offset, sz, data + old_offset); } - } + } - data += old_vtx_size; - dest += exec->vtx.vertex_size; + data += old_vtx_size; + dest += exec->vtx.vertex_size; } exec->vtx.buffer_ptr = dest; @@ -395,6 +404,7 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec, * For example, we saw a bunch of glTexCoord2f() calls and now we got a * glTexCoord4f() call. We promote the array from size=2 to size=4. * \param newSize size of new vertex (number of 32-bit words). + * \param attr VBO_ATTRIB_x vertex attribute value */ static void vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, @@ -402,12 +412,14 @@ vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; + assert(attr < VBO_ATTRIB_MAX); + if (newSize > exec->vtx.attrsz[attr] || newType != exec->vtx.attrtype[attr]) { /* New size is larger. Need to flush existing vertices and get * an enlarged vertex format. */ - vbo_exec_wrap_upgrade_vertex( exec, attr, newSize ); + vbo_exec_wrap_upgrade_vertex(exec, attr, newSize); } else if (newSize < exec->vtx.active_sz[attr]) { GLuint i; @@ -418,16 +430,17 @@ vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, * zeros. Don't need to flush or wrap. */ for (i = newSize; i <= exec->vtx.attrsz[attr]; i++) - exec->vtx.attrptr[attr][i-1] = id[i-1]; + exec->vtx.attrptr[attr][i-1] = id[i-1]; } exec->vtx.active_sz[attr] = newSize; + exec->vtx.attrtype[attr] = newType; /* Does setting NeedFlush belong here? Necessitates resetting * vtxfmt on each flush (otherwise flags won't get reset * afterwards). */ - if (attr == 0) + if (attr == 0) ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; } @@ -440,7 +453,7 @@ vbo_exec_begin_vertices(struct gl_context *ctx) { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; - vbo_exec_vtx_map( exec ); + vbo_exec_vtx_map(exec); assert((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0); assert(exec->begin_vertices_flags); @@ -452,15 +465,15 @@ vbo_exec_begin_vertices(struct gl_context *ctx) /** * This macro is used to implement all the glVertex, glColor, glTexCoord, * glVertexAttrib, etc functions. - * \param A attribute index + * \param A VBO_ATTRIB_x attribute index * \param N attribute size (1..4) * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT) * \param C cast type (fi_type or double) * \param V0, V1, v2, V3 attribute value */ -#define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \ -do { \ - struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \ +#define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \ +do { \ + struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \ int sz = (sizeof(C) / sizeof(GLfloat)); \ \ assert(sz == 1 || sz == 2); \ @@ -469,22 +482,22 @@ do { \ if (unlikely(exec->vtx.active_sz[A] != N * sz) || \ unlikely(exec->vtx.attrtype[A] != T)) { \ vbo_exec_fixup_vertex(ctx, A, N * sz, T); \ - } \ + } \ \ /* store vertex attribute in vertex buffer */ \ - { \ + { \ C *dest = (C *)exec->vtx.attrptr[A]; \ - if (N>0) dest[0] = V0; \ - if (N>1) dest[1] = V1; \ - if (N>2) dest[2] = V2; \ - if (N>3) dest[3] = V3; \ - exec->vtx.attrtype[A] = T; \ - } \ - \ - if ((A) == 0) { \ - /* This is a glVertex call */ \ - GLuint i; \ - \ + if (N>0) dest[0] = V0; \ + if (N>1) dest[1] = V1; \ + if (N>2) dest[2] = V2; \ + if (N>3) dest[3] = V3; \ + assert(exec->vtx.attrtype[A] == T); \ + } \ + \ + if ((A) == 0) { \ + /* This is a glVertex call */ \ + GLuint i; \ + \ if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \ vbo_exec_begin_vertices(ctx); \ } \ @@ -495,24 +508,26 @@ do { \ assert(exec->vtx.buffer_ptr); \ \ /* copy 32-bit words */ \ - for (i = 0; i < exec->vtx.vertex_size; i++) \ - exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \ - \ - exec->vtx.buffer_ptr += exec->vtx.vertex_size; \ - \ - /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \ - /* something to draw (not just updating a color or texcoord).*/ \ - ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \ - \ - if (++exec->vtx.vert_count >= exec->vtx.max_vert) \ - vbo_exec_vtx_wrap( exec ); \ + for (i = 0; i < exec->vtx.vertex_size; i++) \ + exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \ + \ + exec->vtx.buffer_ptr += exec->vtx.vertex_size; \ + \ + /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \ + /* something to draw (not just updating a color or texcoord).*/ \ + ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \ + \ + if (++exec->vtx.vert_count >= exec->vtx.max_vert) \ + vbo_exec_vtx_wrap(exec); \ } else { \ /* we now have accumulated per-vertex attributes */ \ ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \ } \ } while (0) -#define ERROR(err) _mesa_error( ctx, err, __func__ ) + +#undef ERROR +#define ERROR(err) _mesa_error(ctx, err, __func__) #define TAG(x) vbo_##x #include "vbo_attrib_tmp.h" @@ -582,7 +597,7 @@ vbo_Materialfv(GLenum face, GLenum pname, const GLfloat *params) if (*params < 0 || *params > ctx->Const.MaxShininess) { _mesa_error(ctx, GL_INVALID_VALUE, "glMaterial(invalid shininess: %f out range [0, %f])", - *params, ctx->Const.MaxShininess); + *params, ctx->Const.MaxShininess); return; } if (updateMats & MAT_BIT_FRONT_SHININESS) @@ -625,114 +640,124 @@ static void vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec, GLboolean unmap) { if (exec->vtx.vert_count || unmap) { - vbo_exec_vtx_flush( exec, unmap ); + vbo_exec_vtx_flush(exec, unmap); } if (exec->vtx.vertex_size) { - vbo_exec_copy_to_current( exec ); - reset_attrfv( exec ); + vbo_exec_copy_to_current(exec); + vbo_reset_all_attr(exec); } } -static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u ) +static void GLAPIENTRY +vbo_exec_EvalCoord1f(GLfloat u) { - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); struct vbo_exec_context *exec = &vbo_context(ctx)->exec; { GLint i; - if (exec->eval.recalculate_maps) - vbo_exec_eval_update( exec ); + if (exec->eval.recalculate_maps) + vbo_exec_eval_update(exec); for (i = 0; i <= VBO_ATTRIB_TEX7; i++) { - if (exec->eval.map1[i].map) - if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz) - vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz, GL_FLOAT ); + if (exec->eval.map1[i].map) + if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz) + vbo_exec_fixup_vertex(ctx, i, exec->eval.map1[i].sz, GL_FLOAT); } } + memcpy(exec->vtx.copied.buffer, exec->vtx.vertex, + exec->vtx.vertex_size * sizeof(GLfloat)); - memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, - exec->vtx.vertex_size * sizeof(GLfloat)); + vbo_exec_do_EvalCoord1f(exec, u); - vbo_exec_do_EvalCoord1f( exec, u ); - - memcpy( exec->vtx.vertex, exec->vtx.copied.buffer, - exec->vtx.vertex_size * sizeof(GLfloat)); + memcpy(exec->vtx.vertex, exec->vtx.copied.buffer, + exec->vtx.vertex_size * sizeof(GLfloat)); } -static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v ) + +static void GLAPIENTRY +vbo_exec_EvalCoord2f(GLfloat u, GLfloat v) { - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); struct vbo_exec_context *exec = &vbo_context(ctx)->exec; { GLint i; - if (exec->eval.recalculate_maps) - vbo_exec_eval_update( exec ); + if (exec->eval.recalculate_maps) + vbo_exec_eval_update(exec); for (i = 0; i <= VBO_ATTRIB_TEX7; i++) { - if (exec->eval.map2[i].map) - if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz) - vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz, GL_FLOAT ); + if (exec->eval.map2[i].map) + if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz) + vbo_exec_fixup_vertex(ctx, i, exec->eval.map2[i].sz, GL_FLOAT); } - if (ctx->Eval.AutoNormal) - if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3) - vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3, GL_FLOAT ); + if (ctx->Eval.AutoNormal) + if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3) + vbo_exec_fixup_vertex(ctx, VBO_ATTRIB_NORMAL, 3, GL_FLOAT); } - memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, - exec->vtx.vertex_size * sizeof(GLfloat)); + memcpy(exec->vtx.copied.buffer, exec->vtx.vertex, + exec->vtx.vertex_size * sizeof(GLfloat)); - vbo_exec_do_EvalCoord2f( exec, u, v ); + vbo_exec_do_EvalCoord2f(exec, u, v); - memcpy( exec->vtx.vertex, exec->vtx.copied.buffer, - exec->vtx.vertex_size * sizeof(GLfloat)); + memcpy(exec->vtx.vertex, exec->vtx.copied.buffer, + exec->vtx.vertex_size * sizeof(GLfloat)); } -static void GLAPIENTRY vbo_exec_EvalCoord1fv( const GLfloat *u ) + +static void GLAPIENTRY +vbo_exec_EvalCoord1fv(const GLfloat *u) { - vbo_exec_EvalCoord1f( u[0] ); + vbo_exec_EvalCoord1f(u[0]); } -static void GLAPIENTRY vbo_exec_EvalCoord2fv( const GLfloat *u ) + +static void GLAPIENTRY +vbo_exec_EvalCoord2fv(const GLfloat *u) { - vbo_exec_EvalCoord2f( u[0], u[1] ); + vbo_exec_EvalCoord2f(u[0], u[1]); } -static void GLAPIENTRY vbo_exec_EvalPoint1( GLint i ) + +static void GLAPIENTRY +vbo_exec_EvalPoint1(GLint i) { - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) / - (GLfloat) ctx->Eval.MapGrid1un); + (GLfloat) ctx->Eval.MapGrid1un); GLfloat u = i * du + ctx->Eval.MapGrid1u1; - vbo_exec_EvalCoord1f( u ); + vbo_exec_EvalCoord1f(u); } -static void GLAPIENTRY vbo_exec_EvalPoint2( GLint i, GLint j ) +static void GLAPIENTRY +vbo_exec_EvalPoint2(GLint i, GLint j) { - GET_CURRENT_CONTEXT( ctx ); - GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / - (GLfloat) ctx->Eval.MapGrid2un); - GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / - (GLfloat) ctx->Eval.MapGrid2vn); + GET_CURRENT_CONTEXT(ctx); + GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / + (GLfloat) ctx->Eval.MapGrid2un); + GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / + (GLfloat) ctx->Eval.MapGrid2vn); GLfloat u = i * du + ctx->Eval.MapGrid2u1; GLfloat v = j * dv + ctx->Eval.MapGrid2v1; - vbo_exec_EvalCoord2f( u, v ); + vbo_exec_EvalCoord2f(u, v); } /** * Called via glBegin. */ -static void GLAPIENTRY vbo_exec_Begin( GLenum mode ) +static void GLAPIENTRY +vbo_exec_Begin(GLenum mode) { - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); struct vbo_exec_context *exec = &vbo_context(ctx)->exec; int i; @@ -748,7 +773,7 @@ static void GLAPIENTRY vbo_exec_Begin( GLenum mode ) vbo_draw_method(vbo_context(ctx), DRAW_BEGIN_END); if (ctx->NewState) { - _mesa_update_state( ctx ); + _mesa_update_state(ctx); CALL_Begin(ctx->Exec, (mode)); return; @@ -783,11 +808,11 @@ static void GLAPIENTRY vbo_exec_Begin( GLenum mode ) /* We may have been called from a display list, in which case we should * leave dlist.c's dispatch table in place. */ - if (ctx->CurrentDispatch == ctx->OutsideBeginEnd) { - ctx->CurrentDispatch = ctx->BeginEnd; - _glapi_set_dispatch(ctx->CurrentDispatch); + if (ctx->CurrentClientDispatch == ctx->OutsideBeginEnd) { + ctx->CurrentClientDispatch = ctx->BeginEnd; + _glapi_set_dispatch(ctx->CurrentClientDispatch); } else { - assert(ctx->CurrentDispatch == ctx->Save); + assert(ctx->CurrentClientDispatch == ctx->Save); } } @@ -823,9 +848,10 @@ try_vbo_merge(struct vbo_exec_context *exec) /** * Called via glEnd. */ -static void GLAPIENTRY vbo_exec_End( void ) +static void GLAPIENTRY +vbo_exec_End(void) { - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); struct vbo_exec_context *exec = &vbo_context(ctx)->exec; if (!_mesa_inside_begin_end(ctx)) { @@ -834,9 +860,9 @@ static void GLAPIENTRY vbo_exec_End( void ) } ctx->Exec = ctx->OutsideBeginEnd; - if (ctx->CurrentDispatch == ctx->BeginEnd) { - ctx->CurrentDispatch = ctx->OutsideBeginEnd; - _glapi_set_dispatch(ctx->CurrentDispatch); + if (ctx->CurrentClientDispatch == ctx->BeginEnd) { + ctx->CurrentClientDispatch = ctx->OutsideBeginEnd; + _glapi_set_dispatch(ctx->CurrentClientDispatch); } if (exec->vtx.prim_count > 0) { @@ -876,7 +902,7 @@ static void GLAPIENTRY vbo_exec_End( void ) ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END; if (exec->vtx.prim_count == VBO_MAX_PRIM) - vbo_exec_vtx_flush( exec, GL_FALSE ); + vbo_exec_vtx_flush(exec, GL_FALSE); if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) { _mesa_flush(ctx); @@ -891,12 +917,12 @@ static void GLAPIENTRY vbo_exec_PrimitiveRestartNV(void) { GLenum curPrim; - GET_CURRENT_CONTEXT( ctx ); + GET_CURRENT_CONTEXT(ctx); curPrim = ctx->Driver.CurrentExecPrimitive; if (curPrim == PRIM_OUTSIDE_BEGIN_END) { - _mesa_error( ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV" ); + _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV"); } else { vbo_exec_End(); @@ -905,8 +931,8 @@ vbo_exec_PrimitiveRestartNV(void) } - -static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec ) +static void +vbo_exec_vtxfmt_init(struct vbo_exec_context *exec) { struct gl_context *ctx = exec->ctx; GLvertexformat *vfmt = &exec->vtxfmt; @@ -961,7 +987,7 @@ static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec ) vfmt->Vertex3fv = vbo_Vertex3fv; vfmt->Vertex4f = vbo_Vertex4f; vfmt->Vertex4fv = vbo_Vertex4fv; - + if (ctx->API == API_OPENGLES2) { vfmt->VertexAttrib1fARB = _es_VertexAttrib1f; vfmt->VertexAttrib1fvARB = _es_VertexAttrib1fv; @@ -1044,7 +1070,7 @@ static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec ) vfmt->MultiTexCoordP3uiv = vbo_MultiTexCoordP3uiv; vfmt->MultiTexCoordP4ui = vbo_MultiTexCoordP4ui; vfmt->MultiTexCoordP4uiv = vbo_MultiTexCoordP4uiv; - + vfmt->NormalP3ui = vbo_NormalP3ui; vfmt->NormalP3uiv = vbo_NormalP3uiv; @@ -1074,6 +1100,9 @@ static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec ) vfmt->VertexAttribL2dv = vbo_VertexAttribL2dv; vfmt->VertexAttribL3dv = vbo_VertexAttribL3dv; vfmt->VertexAttribL4dv = vbo_VertexAttribL4dv; + + vfmt->VertexAttribL1ui64ARB = vbo_VertexAttribL1ui64ARB; + vfmt->VertexAttribL1ui64vARB = vbo_VertexAttribL1ui64vARB; } @@ -1083,7 +1112,8 @@ static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec ) * This replaces the malloced buffer which was created in * vb_exec_vtx_init() below. */ -void vbo_use_buffer_objects(struct gl_context *ctx) +void +vbo_use_buffer_objects(struct gl_context *ctx) { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; /* Any buffer name but 0 can be used here since this bufferobj won't @@ -1128,7 +1158,8 @@ vbo_always_unmap_buffers(struct gl_context *ctx) } -void vbo_exec_vtx_init( struct vbo_exec_context *exec ) +void +vbo_exec_vtx_init(struct vbo_exec_context *exec) { struct gl_context *ctx = exec->ctx; struct vbo_context *vbo = vbo_context(ctx); @@ -1146,7 +1177,7 @@ void vbo_exec_vtx_init( struct vbo_exec_context *exec ) exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64); exec->vtx.buffer_ptr = exec->vtx.buffer_map; - vbo_exec_vtxfmt_init( exec ); + vbo_exec_vtxfmt_init(exec); _mesa_noop_vtxfmt_init(&exec->vtxfmt_noop); exec->vtx.enabled = 0; @@ -1163,19 +1194,19 @@ void vbo_exec_vtx_init( struct vbo_exec_context *exec ) assert(i < ARRAY_SIZE(exec->vtx.arrays)); exec->vtx.inputs[i] = &exec->vtx.arrays[i]; } - + { - struct gl_client_array *arrays = exec->vtx.arrays; + struct gl_vertex_array *arrays = exec->vtx.arrays; unsigned i; memcpy(arrays, &vbo->currval[VBO_ATTRIB_POS], VERT_ATTRIB_FF_MAX * sizeof(arrays[0])); for (i = 0; i < VERT_ATTRIB_FF_MAX; ++i) { - struct gl_client_array *array; + struct gl_vertex_array *array; array = &arrays[VERT_ATTRIB_FF(i)]; array->BufferObj = NULL; _mesa_reference_buffer_object(ctx, &array->BufferObj, - vbo->currval[VBO_ATTRIB_POS+i].BufferObj); + vbo->currval[VBO_ATTRIB_POS+i].BufferObj); } memcpy(arrays + VERT_ATTRIB_GENERIC(0), @@ -1183,7 +1214,7 @@ void vbo_exec_vtx_init( struct vbo_exec_context *exec ) VERT_ATTRIB_GENERIC_MAX * sizeof(arrays[0])); for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; ++i) { - struct gl_client_array *array; + struct gl_vertex_array *array; array = &arrays[VERT_ATTRIB_GENERIC(i)]; array->BufferObj = NULL; _mesa_reference_buffer_object(ctx, &array->BufferObj, @@ -1197,7 +1228,8 @@ void vbo_exec_vtx_init( struct vbo_exec_context *exec ) } -void vbo_exec_vtx_destroy( struct vbo_exec_context *exec ) +void +vbo_exec_vtx_destroy(struct vbo_exec_context *exec) { /* using a real VBO for vertex data */ struct gl_context *ctx = exec->ctx; @@ -1243,7 +1275,8 @@ void vbo_exec_vtx_destroy( struct vbo_exec_context *exec ) * * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT */ -void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags ) +void +vbo_exec_FlushVertices(struct gl_context *ctx, GLuint flags) { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; @@ -1276,20 +1309,29 @@ void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags ) } -static void reset_attrfv( struct vbo_exec_context *exec ) -{ +/** + * Reset the vertex attribute by setting its size to zero. + */ +static void +vbo_reset_attr(struct vbo_exec_context *exec, GLuint attr) +{ + exec->vtx.attrsz[attr] = 0; + exec->vtx.attrtype[attr] = GL_FLOAT; + exec->vtx.active_sz[attr] = 0; +} + + +static void +vbo_reset_all_attr(struct vbo_exec_context *exec) +{ while (exec->vtx.enabled) { const int i = u_bit_scan64(&exec->vtx.enabled); - assert(exec->vtx.attrsz[i]); - - exec->vtx.attrsz[i] = 0; - exec->vtx.attrtype[i] = GL_FLOAT; - exec->vtx.active_sz[i] = 0; + vbo_reset_attr(exec, i); } exec->vtx.vertex_size = 0; } - + void GLAPIENTRY _es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)