X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglx%2Findirect_vertex_array.c;h=c81aae603866c8f3e7d7ba9e2a01c9a409f48787;hb=84395190ec8cae6158737777c8def7cc3304eb3f;hp=2bf2ff1bdb6bf7263b567d531efbfdc158578fcd;hpb=05e7f7f4388bde882b7ce74124000a4d435affff;p=mesa.git diff --git a/src/glx/indirect_vertex_array.c b/src/glx/indirect_vertex_array.c index 2bf2ff1bdb6..c81aae60386 100644 --- a/src/glx/indirect_vertex_array.c +++ b/src/glx/indirect_vertex_array.c @@ -151,6 +151,7 @@ __glXInitVertexArrayState(struct glx_context * gc) arrays = calloc(1, sizeof(struct array_state_vector)); + state->array_state = arrays; if (arrays == NULL) { __glXSetError(gc, GL_OUT_OF_MEMORY); @@ -206,6 +207,7 @@ __glXInitVertexArrayState(struct glx_context * gc) arrays->arrays = calloc(array_count, sizeof(struct array_state)); if (arrays->arrays == NULL) { + state->array_state = NULL; free(arrays); __glXSetError(gc, GL_OUT_OF_MEMORY); return; @@ -240,8 +242,6 @@ __glXInitVertexArrayState(struct glx_context * gc) arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0); arrays->arrays[4 + i].index = i; - - arrays->arrays[4 + i].header[1] = i + GL_TEXTURE0; } i = 4 + texture_units; @@ -274,8 +274,6 @@ __glXInitVertexArrayState(struct glx_context * gc) arrays->arrays[idx + i].old_DrawArrays_possible = 0; arrays->arrays[idx + i].index = idx; - - arrays->arrays[idx + i].header[1] = idx; } i += vertex_program_attribs; @@ -298,16 +296,12 @@ __glXInitVertexArrayState(struct glx_context * gc) * __GL_CLIENT_ATTRIB_STACK_DEPTH); if (arrays->stack == NULL) { + state->array_state = NULL; free(arrays->arrays); free(arrays); __glXSetError(gc, GL_OUT_OF_MEMORY); return; } - - /* Everything went ok so we put vertex array state in place - * in context. - */ - state->array_state = arrays; } @@ -325,7 +319,7 @@ calculate_single_vertex_size_none(const struct array_state_vector *arrays) for (i = 0; i < arrays->num_arrays; i++) { if (arrays->arrays[i].enabled) { - single_vertex_size += ((uint16_t *) arrays->arrays[i].header)[0]; + single_vertex_size += arrays->arrays[i].header[0]; } } @@ -353,17 +347,45 @@ emit_element_none(GLubyte * dst, * protocol is for a 4Nus. Since the sizes are small, the * performance impact on modern processors should be negligible. */ - (void) memset(dst, 0, ((uint16_t *) arrays->arrays[i].header)[0]); - - (void) memcpy(dst, arrays->arrays[i].header, - arrays->arrays[i].header_size); - - dst += arrays->arrays[i].header_size; - - (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset, - arrays->arrays[i].element_size); - - dst += __GLX_PAD(arrays->arrays[i].element_size); + (void) memset(dst, 0, arrays->arrays[i].header[0]); + + (void) memcpy(dst, arrays->arrays[i].header, 4); + + dst += 4; + + if (arrays->arrays[i].key == GL_TEXTURE_COORD_ARRAY && + arrays->arrays[i].index > 0) { + /* Multi-texture coordinate arrays require the texture target + * to be sent. For doubles it is after the data, for everything + * else it is before. + */ + GLenum texture = arrays->arrays[i].index + GL_TEXTURE0; + if (arrays->arrays[i].data_type == GL_DOUBLE) { + (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset, + arrays->arrays[i].element_size); + dst += arrays->arrays[i].element_size; + (void) memcpy(dst, &texture, 4); + dst += 4; + } else { + (void) memcpy(dst, &texture, 4); + dst += 4; + (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset, + arrays->arrays[i].element_size); + dst += __GLX_PAD(arrays->arrays[i].element_size); + } + } else if (arrays->arrays[i].key == GL_VERTEX_ATTRIB_ARRAY_POINTER) { + /* Vertex attribute data requires the index sent first. + */ + (void) memcpy(dst, &arrays->arrays[i].index, 4); + dst += 4; + (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset, + arrays->arrays[i].element_size); + dst += __GLX_PAD(arrays->arrays[i].element_size); + } else { + (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset, + arrays->arrays[i].element_size); + dst += __GLX_PAD(arrays->arrays[i].element_size); + } } } @@ -1099,6 +1121,10 @@ __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, } +/* The HDR_SIZE macro argument is the command header size (4 bytes) + * plus any additional index word e.g. for texture units or vertex + * attributes. + */ #define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, NORMALIZED, HDR_SIZE, OPCODE) \ do { \ (a)->data = PTR; \ @@ -1111,9 +1137,8 @@ __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, (a)->true_stride = (STRIDE == 0) \ ? (a)->element_size : STRIDE; \ \ - (a)->header_size = HDR_SIZE; \ - ((uint16_t *) (a)->header)[0] = __GLX_PAD((a)->header_size + (a)->element_size); \ - ((uint16_t *) (a)->header)[1] = OPCODE; \ + (a)->header[0] = __GLX_PAD(HDR_SIZE + (a)->element_size); \ + (a)->header[1] = OPCODE; \ } while(0) @@ -1386,7 +1411,7 @@ __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, X_GLrop_TexCoord4iv }; static const uint16_t float_ops[5] = { - 0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv, + 0, X_GLrop_TexCoord1fv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv, X_GLrop_TexCoord4fv }; static const uint16_t double_ops[5] = { @@ -1403,7 +1428,7 @@ __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, X_GLrop_MultiTexCoord3ivARB, X_GLrop_MultiTexCoord4ivARB }; static const uint16_t mfloat_ops[5] = { - 0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2fvARB, + 0, X_GLrop_MultiTexCoord1fvARB, X_GLrop_MultiTexCoord2fvARB, X_GLrop_MultiTexCoord3fvARB, X_GLrop_MultiTexCoord4fvARB }; static const uint16_t mdouble_ops[5] = { @@ -1587,9 +1612,18 @@ __indirect_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) { - static const uint16_t short_ops[5] = { 0, 4189, 4190, 4191, 4192 }; - static const uint16_t float_ops[5] = { 0, 4193, 4194, 4195, 4196 }; - static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 }; + static const uint16_t short_ops[5] = { + 0, X_GLrop_VertexAttrib1svARB, X_GLrop_VertexAttrib2svARB, + X_GLrop_VertexAttrib3svARB, X_GLrop_VertexAttrib4svARB + }; + static const uint16_t float_ops[5] = { + 0, X_GLrop_VertexAttrib1fvARB, X_GLrop_VertexAttrib2fvARB, + X_GLrop_VertexAttrib3fvARB, X_GLrop_VertexAttrib4fvARB + }; + static const uint16_t double_ops[5] = { + 0, X_GLrop_VertexAttrib1dvARB, X_GLrop_VertexAttrib2dvARB, + X_GLrop_VertexAttrib3dvARB, X_GLrop_VertexAttrib4dvARB + }; uint16_t opcode; struct glx_context *gc = __glXGetCurrentContext(); @@ -1682,8 +1716,7 @@ __indirect_glVertexAttribPointer(GLuint index, GLint size, opcode); true_immediate_size = __glXTypeSize(type) * true_immediate_count; - ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size - + true_immediate_size); + a->header[0] = __GLX_PAD(8 + true_immediate_size); if (a->enabled) { arrays->array_info_cache_valid = GL_FALSE;