void __indirect_glEnable(GLenum cap) { __GLX_DECLARE_VARIABLES(); __GLX_LOAD_VARIABLES(); if (!gc->currentDpy) return; switch (cap) { case GL_COLOR_ARRAY: case GL_EDGE_FLAG_ARRAY: case GL_INDEX_ARRAY: case GL_NORMAL_ARRAY: case GL_TEXTURE_COORD_ARRAY: case GL_VERTEX_ARRAY: case GL_SECONDARY_COLOR_ARRAY: case GL_FOG_COORD_ARRAY: __indirect_glEnableClientState(cap); return; default: break; } __GLX_BEGIN(X_GLrop_Enable, 8); __GLX_PUT_LONG(4, cap); __GLX_END(8); }
void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer) { struct glx_context *gc = __glXGetCurrentContext(); __GLXattribute *state = (__GLXattribute *) (gc->client_state_private); #define NONE {0, 0, 0} #define F(x) {GL_FLOAT, x, x * sizeof(GLfloat)} #define UB4 {GL_UNSIGNED_BYTE, 4, 4 * sizeof(GLubyte)} /* Each row in this array describes the elements of a particular * interleaved array mode. Each column describes, in the order in which * they appear in the interleaved arrays, one of the four possible types * of vertex data that can appear in an interleaved array. */ struct { /** * The enum describing the GL type, as would be passed to the * appropriate gl*Pointer function. */ GLushort type; /** * Number of elements in the subarray, as would be passed (as the * \c size parameter) to the appropriate gl*Pointer function. */ GLubyte count; /** * True size of a single element in the subarray, as would be passed * (as the \c stride parameter) to the appropriate gl*Pointer * function. */ GLubyte size; } static const modes[14][4] = { /* texture color normal vertex */ {NONE, NONE, NONE, F(2)}, /* GL_V2F */ {NONE, NONE, NONE, F(3)}, /* GL_V3F */ {NONE, UB4, NONE, F(2)}, /* GL_C4UB_V2F */ {NONE, UB4, NONE, F(3)}, /* GL_C4UB_V3F */ {NONE, F(3), NONE, F(3)}, /* GL_C3F_V3F */ {NONE, NONE, F(3), F(3)}, /* GL_N3F_V3F */ {NONE, F(4), F(3), F(3)}, /* GL_C4F_N3F_V3F */ {F(2), NONE, NONE, F(3)}, /* GL_T2F_V3F */ {F(4), NONE, NONE, F(4)}, /* GL_T4F_V4F */ {F(2), UB4, NONE, F(3)}, /* GL_T2F_C4UB_V3F */ {F(2), F(3), NONE, F(3)}, /* GL_T2F_C3F_V3F */ {F(2), NONE, F(3), F(3)}, /* GL_T2F_N3F_V3F */ {F(2), F(4), F(3), F(3)}, /* GL_T2F_C4F_N3F_V3F */ {F(4), F(4), F(3), F(4)}, /* GL_T4F_C4F_N3F_V4F */ }; #undef NONE #undef F #undef UB4 GLint trueStride, size; int offsets[4]; unsigned i; const int idx = format - GL_V2F; /* All valid formats are on the range [GL_V2F, GL_V2F+0x0D]. Since idx * is just the format biased by -GL_V2F, all valid idx values are on the * range [0, 0x0D]. */ if ((idx < 0) || (idx > 0x0D)) { __glXSetError(gc, GL_INVALID_ENUM); return; } if (stride < 0) { __glXSetError(gc, GL_INVALID_VALUE); return; } /* If the 'count' for a subarray is non-zero, then the offset of its * first element is at the currently accumulated 'size'. */ size = 0; for (i = 0; i < 4; i++) { offsets[i] = (modes[idx][i].count != 0) ? size : -1; size += modes[idx][i].size; } trueStride = (stride == 0) ? size : stride; __glXArrayDisableAll(state); if (offsets[0] >= 0) { __indirect_glEnableClientState(GL_TEXTURE_COORD_ARRAY); __indirect_glTexCoordPointer(modes[idx][0].count, GL_FLOAT, trueStride, (const char *) pointer); } if (offsets[1] >= 0) { __indirect_glEnableClientState(GL_COLOR_ARRAY); __indirect_glColorPointer(modes[idx][1].count, modes[idx][1].type, trueStride, (const char *) pointer + offsets[1]); } if (offsets[2] >= 0) { __indirect_glEnableClientState(GL_NORMAL_ARRAY); __indirect_glNormalPointer(GL_FLOAT, trueStride, (const char *) pointer + offsets[2]); } __indirect_glEnableClientState(GL_VERTEX_ARRAY); __indirect_glVertexPointer(modes[idx][3].count, GL_FLOAT, trueStride, (const char *) pointer + offsets[3]); }
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); }