void __indirect_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *fogPointer = &state->vertArray.arrays[ fogCoord_ARRAY ]; /* Check arguments */ if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_FOG_FUNC(FLOAT, f); __GL_FOG_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } fogPointer->size = 1; fogPointer->type = type; fogPointer->stride = stride; fogPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { fogPointer->skip = __glXTypeSize(type); } else { fogPointer->skip = stride; } }
void __indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *indexPointer = &state->vertArray.arrays[ index_ARRAY ]; /* Check arguments */ if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_INDEX_FUNC(UNSIGNED_BYTE, ub); __GL_INDEX_FUNC(SHORT, s); __GL_INDEX_FUNC(INT, i); __GL_INDEX_FUNC(FLOAT, f); __GL_INDEX_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } indexPointer->type = type; indexPointer->stride = stride; indexPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { indexPointer->skip = __glXTypeSize(type); } else { indexPointer->skip = stride; } }
void __indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer ) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *seccolorPointer = &state->vertArray.arrays[ secondaryColor_ARRAY ]; /* Check arguments */ if ( (stride < 0) || (size != 3) ) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_SEC_COLOR_FUNC(BYTE, b); __GL_SEC_COLOR_FUNC(UNSIGNED_BYTE, ub); __GL_SEC_COLOR_FUNC(SHORT, s); __GL_SEC_COLOR_FUNC(UNSIGNED_SHORT, us); __GL_SEC_COLOR_FUNC(INT, i); __GL_SEC_COLOR_FUNC(UNSIGNED_INT, ui); __GL_SEC_COLOR_FUNC(FLOAT, f); __GL_SEC_COLOR_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } seccolorPointer->size = size; seccolorPointer->type = type; seccolorPointer->stride = stride; seccolorPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { seccolorPointer->skip = size * __glXTypeSize(type); } else { seccolorPointer->skip = stride; } }
void __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); __GLXvertexArrayPointerState *texCoordPointer = &state->vertArray.texCoord[state->vertArray.activeTexture]; /* Check arguments */ if (size < 1 || size > 4 || stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* Choose appropriate api proc */ switch(type) { __GL_TEXTURE_FUNC(SHORT, s); __GL_TEXTURE_FUNC(INT, i); __GL_TEXTURE_FUNC(FLOAT, f); __GL_TEXTURE_FUNC(DOUBLE, d); default: __glXSetError(gc, GL_INVALID_ENUM); return; } texCoordPointer->size = size; texCoordPointer->type = type; texCoordPointer->stride = stride; texCoordPointer->ptr = pointer; /* Set internal state */ if (stride == 0) { texCoordPointer->skip = __glXTypeSize(type) * size; } else { texCoordPointer->skip = stride; } }
int __glXDrawArraysReqSize(const GLbyte * pc, Bool swap, int reqlen) { __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; __GLXdispatchDrawArraysComponentHeader *compHeader; GLint numVertexes = hdr->numVertexes; GLint numComponents = hdr->numComponents; GLint arrayElementSize = 0; GLint x, size; int i; if (swap) { numVertexes = SWAPL(numVertexes); numComponents = SWAPL(numComponents); } pc += sizeof(__GLXdispatchDrawArraysHeader); reqlen -= sizeof(__GLXdispatchDrawArraysHeader); size = safe_mul(sizeof(__GLXdispatchDrawArraysComponentHeader), numComponents); if (size < 0 || reqlen < 0 || reqlen < size) return -1; compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLint component = compHeader[i].component; if (swap) { datatype = SWAPL(datatype); numVals = SWAPL(numVals); component = SWAPL(component); } switch (component) { case GL_VERTEX_ARRAY: case GL_COLOR_ARRAY: case GL_TEXTURE_COORD_ARRAY: break; case GL_SECONDARY_COLOR_ARRAY: case GL_NORMAL_ARRAY: if (numVals != 3) { /* bad size */ return -1; } break; case GL_FOG_COORD_ARRAY: case GL_INDEX_ARRAY: if (numVals != 1) { /* bad size */ return -1; } break; case GL_EDGE_FLAG_ARRAY: if ((numVals != 1) && (datatype != GL_UNSIGNED_BYTE)) { /* bad size or bad type */ return -1; } break; default: /* unknown component type */ return -1; } x = safe_pad(safe_mul(numVals, __glXTypeSize(datatype))); if ((arrayElementSize = safe_add(arrayElementSize, x)) < 0) return -1; pc += sizeof(__GLXdispatchDrawArraysComponentHeader); } return safe_add(size, safe_mul(numVertexes, arrayElementSize)); }
void __glXDispSwap_DrawArrays(GLbyte * pc) { __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; __GLXdispatchDrawArraysComponentHeader *compHeader; GLint numVertexes = hdr->numVertexes; GLint numComponents = hdr->numComponents; GLenum primType = hdr->primType; GLint stride = 0; int i; __GLX_DECLARE_SWAP_VARIABLES; __GLX_SWAP_INT(&numVertexes); __GLX_SWAP_INT(&numComponents); __GLX_SWAP_INT(&primType); pc += sizeof(__GLXdispatchDrawArraysHeader); compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; /* compute stride (same for all component arrays) */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; __GLX_SWAP_INT(&datatype); __GLX_SWAP_INT(&numVals); __GLX_SWAP_INT(&component); stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); } pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader); /* set up component arrays */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; __GLX_SWAP_INT(&datatype); __GLX_SWAP_INT(&numVals); __GLX_SWAP_INT(&component); swapArray(numVals, datatype, stride, numVertexes, pc); switch (component) { case GL_VERTEX_ARRAY: glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(numVals, datatype, stride, pc); break; case GL_NORMAL_ARRAY: glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(datatype, stride, pc); break; case GL_COLOR_ARRAY: glEnableClientState(GL_COLOR_ARRAY); glColorPointer(numVals, datatype, stride, pc); break; case GL_INDEX_ARRAY: glEnableClientState(GL_INDEX_ARRAY); glIndexPointer(datatype, stride, pc); break; case GL_TEXTURE_COORD_ARRAY: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(numVals, datatype, stride, pc); break; case GL_EDGE_FLAG_ARRAY: glEnableClientState(GL_EDGE_FLAG_ARRAY); glEdgeFlagPointer(stride, (const GLboolean *) pc); break; case GL_SECONDARY_COLOR_ARRAY: { PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT = __glGetProcAddress("glSecondaryColorPointerEXT"); glEnableClientState(GL_SECONDARY_COLOR_ARRAY); SecondaryColorPointerEXT(numVals, datatype, stride, pc); break; } case GL_FOG_COORD_ARRAY: { PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT = __glGetProcAddress("glFogCoordPointerEXT"); glEnableClientState(GL_FOG_COORD_ARRAY); FogCoordPointerEXT(datatype, stride, pc); break; } default: break; } pc += __GLX_PAD(numVals * __glXTypeSize(datatype)); } glDrawArrays(primType, 0, numVertexes); /* turn off anything we might have turned on */ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_INDEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_EDGE_FLAG_ARRAY); glDisableClientState(GL_SECONDARY_COLOR_ARRAY); glDisableClientState(GL_FOG_COORD_ARRAY); }
void __indirect_glVertexAttribPointerARB(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 }; uint16_t opcode; __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); struct array_state_vector * arrays = state->array_state; struct array_state * a; unsigned true_immediate_count; unsigned true_immediate_size; if ( (size < 1) || (size > 4) || (stride < 0) || (index > arrays->num_vertex_program_attribs) ){ __glXSetError(gc, GL_INVALID_VALUE); return; } if ( normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) { switch( type ) { case GL_BYTE: opcode = X_GLrop_VertexAttrib4NbvARB; break; case GL_UNSIGNED_BYTE: opcode = X_GLrop_VertexAttrib4NubvARB; break; case GL_SHORT: opcode = X_GLrop_VertexAttrib4NsvARB; break; case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4NusvARB; break; case GL_INT: opcode = X_GLrop_VertexAttrib4NivARB; break; case GL_UNSIGNED_INT: opcode = X_GLrop_VertexAttrib4NuivARB; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } true_immediate_count = 4; } else { true_immediate_count = size; switch( type ) { case GL_BYTE: opcode = X_GLrop_VertexAttrib4bvARB; true_immediate_count = 4; break; case GL_UNSIGNED_BYTE: opcode = X_GLrop_VertexAttrib4ubvARB; true_immediate_count = 4; break; case GL_SHORT: opcode = short_ops[size]; break; case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4usvARB; true_immediate_count = 4; break; case GL_INT: opcode = X_GLrop_VertexAttrib4ivARB; true_immediate_count = 4; break; case GL_UNSIGNED_INT: opcode = X_GLrop_VertexAttrib4uivARB; true_immediate_count = 4; break; case GL_FLOAT: opcode = float_ops[size]; break; case GL_DOUBLE: opcode = double_ops[size]; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } } a = get_array_entry( arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index ); if ( a == NULL ) { __glXSetError(gc, GL_INVALID_OPERATION); return; } COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, normalized, 8, opcode ); true_immediate_size = __glXTypeSize(type) * true_immediate_count; ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size + true_immediate_size); if ( a->enabled ) { arrays->array_info_cache_valid = GL_FALSE; } }
void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) { __GLXcontext *gc = __glXGetCurrentContext(); __GLXattribute * state = (__GLXattribute *)(gc->client_state_private); GLboolean tEnable = GL_FALSE, cEnable = GL_FALSE, nEnable = GL_FALSE; GLenum tType = GL_FLOAT, nType = GL_FLOAT, vType = GL_FLOAT; GLenum cType = GL_FALSE; GLint tSize = 0, cSize = 0, nSize = 3, vSize; int cOffset = 0, nOffset = 0, vOffset = 0; GLint trueStride, size; switch (format) { case GL_V2F: vSize = 2; size = __glXTypeSize(vType) * vSize; break; case GL_V3F: vSize = 3; size = __glXTypeSize(vType) * vSize; break; case GL_C4UB_V2F: cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; vSize = 2; vOffset = __glXTypeSize(cType) * cSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_C4UB_V3F: cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; vSize = 3; vOffset = __glXTypeSize(vType) * cSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_C3F_V3F: cEnable = GL_TRUE; cSize = 3; cType = GL_FLOAT; vSize = 3; vOffset = __glXTypeSize(cType) * cSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_N3F_V3F: nEnable = GL_TRUE; vSize = 3; vOffset = __glXTypeSize(nType) * nSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_C4F_N3F_V3F: cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; nEnable = GL_TRUE; nOffset = __glXTypeSize(cType) * cSize; vSize = 3; vOffset = nOffset + __glXTypeSize(nType) * nSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T2F_V3F: tEnable = GL_TRUE; tSize = 2; vSize = 3; vOffset = __glXTypeSize(tType) * tSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T4F_V4F: tEnable = GL_TRUE; tSize = 4; vSize = 4; vOffset = __glXTypeSize(tType) * tSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T2F_C4UB_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 4; cType = GL_UNSIGNED_BYTE; cOffset = __glXTypeSize(tType) * tSize; vSize = 3; vOffset = cOffset + __glXTypeSize(cType) * cSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T2F_C3F_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 3; cType = GL_FLOAT; cOffset = __glXTypeSize(tType) * tSize; vSize = 3; vOffset = cOffset + __glXTypeSize(cType) * cSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T2F_N3F_V3F: tEnable = GL_TRUE; tSize = 2; nEnable = GL_TRUE; nOffset = __glXTypeSize(tType) * tSize; vSize = 3; vOffset = nOffset + __glXTypeSize(nType) * nSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T2F_C4F_N3F_V3F: tEnable = GL_TRUE; tSize = 2; cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; cOffset = __glXTypeSize(tType) * tSize; nEnable = GL_TRUE; nOffset = cOffset + __glXTypeSize(cType) * cSize; vSize = 3; vOffset = nOffset + __glXTypeSize(nType) * nSize; size = vOffset + __glXTypeSize(vType) * vSize; break; case GL_T4F_C4F_N3F_V4F: tEnable = GL_TRUE; tSize = 4; cEnable = GL_TRUE; cSize = 4; cType = GL_FLOAT; cOffset = __glXTypeSize(tType) * tSize; nEnable = GL_TRUE; nOffset = cOffset + __glXTypeSize(cType) * cSize; vSize = 4; vOffset = nOffset + __glXTypeSize(nType) * nSize; size = vOffset + __glXTypeSize(vType) * vSize; break; default: __glXSetError(gc, GL_INVALID_ENUM); return; } trueStride = (stride == 0) ? size : stride; state->vertArray.enables = 0; state->vertArray.texture_enables = 0; if (tEnable) { __indirect_glEnableClientState(GL_TEXTURE_COORD_ARRAY); __indirect_glTexCoordPointer(tSize, tType, trueStride, (const char *)pointer); } if (cEnable) { __indirect_glEnableClientState(GL_COLOR_ARRAY); __indirect_glColorPointer(cSize, cType, trueStride, (const char *)pointer+cOffset); } if (nEnable) { __indirect_glEnableClientState(GL_NORMAL_ARRAY); __indirect_glNormalPointer(nType, trueStride, (const char *)pointer+nOffset); } __indirect_glEnableClientState(GL_VERTEX_ARRAY); __indirect_glVertexPointer(vSize, vType, trueStride, (const char *)pointer+vOffset); }
void __glXDispSwap_DrawArrays(GLbyte * pc) { __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; __GLXdispatchDrawArraysComponentHeader *compHeader; GLint numVertexes = hdr->numVertexes; GLint numComponents = hdr->numComponents; GLenum primType = hdr->primType; GLint stride = 0; int i; __GLX_DECLARE_SWAP_VARIABLES; __GLX_SWAP_INT(&numVertexes); __GLX_SWAP_INT(&numComponents); __GLX_SWAP_INT(&primType); pc += sizeof(__GLXdispatchDrawArraysHeader); compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; /* compute stride (same for all component arrays) */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; __GLX_SWAP_INT(&datatype); __GLX_SWAP_INT(&numVals); __GLX_SWAP_INT(&component); stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); } pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader); /* set up component arrays */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; __GLX_SWAP_INT(&datatype); __GLX_SWAP_INT(&numVals); __GLX_SWAP_INT(&component); swapArray(numVals, datatype, stride, numVertexes, pc); switch (component) { case GL_VERTEX_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY)); CALL_VertexPointer(GET_DISPATCH(), (numVals, datatype, stride, pc)); break; case GL_NORMAL_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY)); CALL_NormalPointer(GET_DISPATCH(), (datatype, stride, pc)); break; case GL_COLOR_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY)); CALL_ColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc)); break; case GL_INDEX_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY)); CALL_IndexPointer(GET_DISPATCH(), (datatype, stride, pc)); break; case GL_TEXTURE_COORD_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY)); CALL_TexCoordPointer(GET_DISPATCH(), (numVals, datatype, stride, pc)); break; case GL_EDGE_FLAG_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY)); CALL_EdgeFlagPointer(GET_DISPATCH(), (stride, (const GLboolean *) pc)); break; case GL_SECONDARY_COLOR_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY)); CALL_SecondaryColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc)); break; case GL_FOG_COORD_ARRAY: CALL_EnableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY)); CALL_FogCoordPointer(GET_DISPATCH(), (datatype, stride, pc)); break; default: break; } pc += __GLX_PAD(numVals * __glXTypeSize(datatype)); } CALL_DrawArrays(GET_DISPATCH(), (primType, 0, numVertexes)); /* turn off anything we might have turned on */ CALL_DisableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY)); CALL_DisableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY)); }