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));
}
