GLboolean glIsTexture(GLuint texture)
{
#if 0 /* see comments above */
__GLX_SINGLE_DECLARE_VARIABLES();
GLboolean retval = 0;
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_IsTexture,4);
__GLX_SINGLE_PUT_LONG(0,texture);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
__GLX_SINGLE_END();
return retval;
#else
return glIsTextureEXT(texture);
#endif
}
void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionParameterfv,8);
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,pname);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
if (compsize == 1) {
__GLX_SINGLE_GET_FLOAT(params);
} else {
__GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
}
__GLX_SINGLE_END();
}
void glGetMapiv(GLenum target, GLenum query, GLint *v)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetMapiv,8);
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,query);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
if (compsize == 1) {
__GLX_SINGLE_GET_LONG(v);
} else {
__GLX_SINGLE_GET_LONG_ARRAY(v,compsize);
}
__GLX_SINGLE_END();
}
void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetTexGeniv,8);
__GLX_SINGLE_PUT_LONG(0,coord);
__GLX_SINGLE_PUT_LONG(4,pname);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
if (compsize == 1) {
__GLX_SINGLE_GET_LONG(params);
} else {
__GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
}
__GLX_SINGLE_END();
}
void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetColorTableReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetColorTable,__GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width;
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
width = (int)reply.width;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, buf, table);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void glGetPolygonStipple(GLubyte *mask)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
GLubyte buf[128];
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetPolygonStipple,__GLX_PAD(1));
__GLX_SINGLE_PUT_CHAR(0,GL_FALSE);
__GLX_SINGLE_READ_XREPLY();
if (reply.length == 32) {
__GLX_SINGLE_GET_CHAR_ARRAY(buf,128);
__glEmptyImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, buf, mask);
}
__GLX_SINGLE_END();
}
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameteriv,12);
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,level);
__GLX_SINGLE_PUT_LONG(8,pname);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
if (compsize == 1) {
__GLX_SINGLE_GET_LONG(params);
} else {
__GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
}
__GLX_SINGLE_END();
}
void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type,
GLvoid *values)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXGetMinmaxReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetMinmax,__GLX_PAD(14));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,gc->state.storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(13,reset);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, 2, 1, 1, format, type, buf, values);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
{
#if 0 /* see comments above */
__GLX_SINGLE_DECLARE_VARIABLES();
GLboolean retval = 0;
xGLXSingleReply reply;
__GLX_SINGLE_LOAD_VARIABLES();
if (n < 0) return retval;
cmdlen = 4+n*4;
__GLX_SINGLE_BEGIN(X_GLsop_AreTexturesResident,cmdlen);
__GLX_SINGLE_PUT_LONG(0,n);
__GLX_PUT_LONG_ARRAY(4,textures,n);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
__GLX_SINGLE_GET_CHAR_ARRAY(residences,n);
__GLX_SINGLE_END();
return retval;
#else
return glAreTexturesResidentEXT(n, textures, residences);
#endif
}
GLenum glGetError(void)
{
__GLX_SINGLE_DECLARE_VARIABLES();
GLuint retval = GL_NO_ERROR;
xGLXGetErrorReply reply;
if (gc->error) {
/* Use internal error first */
retval = gc->error;
gc->error = GL_NO_ERROR;
return retval;
}
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
__GLX_SINGLE_READ_XREPLY();
retval = reply.error;
__GLX_SINGLE_END();
return retval;
}
GLboolean
__indirect_glIsEnabled(GLenum cap)
{
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
xGLXSingleReply reply;
GLboolean retval = 0;
GLintptr enable;
if (!dpy)
return 0;
switch (cap) {
case GL_VERTEX_ARRAY:
case GL_NORMAL_ARRAY:
case GL_COLOR_ARRAY:
case GL_INDEX_ARRAY:
case GL_EDGE_FLAG_ARRAY:
case GL_SECONDARY_COLOR_ARRAY:
case GL_FOG_COORD_ARRAY:
retval = __glXGetArrayEnable(state, cap, 0, &enable);
assert(retval);
return (GLboolean) enable;
break;
case GL_TEXTURE_COORD_ARRAY:
retval = __glXGetArrayEnable(state, GL_TEXTURE_COORD_ARRAY,
__glXGetActiveTextureUnit(state), &enable);
assert(retval);
return (GLboolean) enable;
break;
}
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_IsEnabled, 4);
__GLX_SINGLE_PUT_LONG(0, cap);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
__GLX_SINGLE_END();
return retval;
}
GLint
__indirect_glRenderMode(GLenum mode)
{
__GLX_SINGLE_DECLARE_VARIABLES();
GLint retval = 0;
xGLXRenderModeReply reply;
if (!dpy)
return -1;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_RenderMode, 4);
__GLX_SINGLE_PUT_LONG(0, mode);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_RETVAL(retval, GLint);
if (reply.newMode != mode) {
/*
** Switch to new mode did not take effect, therefore an error
** occured. When an error happens the server won't send us any
** other data.
*/
}
else {
/* Read the feedback or selection data */
if (gc->renderMode == GL_FEEDBACK) {
__GLX_SINGLE_GET_SIZE(compsize);
__GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
}
else if (gc->renderMode == GL_SELECT) {
__GLX_SINGLE_GET_SIZE(compsize);
__GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
}
gc->renderMode = mode;
}
__GLX_SINGLE_END();
return retval;
}
GLboolean glIsEnabled(GLenum cap)
{
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
GLboolean retval = 0;
if (!dpy) return 0;
switch(cap) {
case GL_VERTEX_ARRAY:
return state->vertArray.vertex.enable;
case GL_NORMAL_ARRAY:
return state->vertArray.normal.enable;
case GL_COLOR_ARRAY:
return state->vertArray.color.enable;
case GL_INDEX_ARRAY:
return state->vertArray.index.enable;
case GL_TEXTURE_COORD_ARRAY:
return state->vertArray.texCoord[state->vertArray.activeTexture].enable;
case GL_EDGE_FLAG_ARRAY:
return state->vertArray.edgeFlag.enable;
case GL_SECONDARY_COLOR_ARRAY:
return state->vertArray.secondaryColor.enable;
case GL_FOG_COORDINATE_ARRAY:
return state->vertArray.fogCoord.enable;
}
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_IsEnabled,4);
__GLX_SINGLE_PUT_LONG(0,cap);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
__GLX_SINGLE_END();
return retval;
}
void glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
GLvoid *row, GLvoid *column, GLvoid *span)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXGetSeparableFilterReply reply;
GLubyte *rowBuf, *colBuf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetSeparableFilter, __GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,format);
__GLX_SINGLE_PUT_LONG(8,type);
__GLX_SINGLE_PUT_CHAR(12,gc->state.storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
GLint width, height;
GLint widthsize, heightsize;
width = reply.width;
height = reply.height;
widthsize = __glImageSize(width,1,1,format, type);
heightsize = __glImageSize(height,1,1,format, type);
/* Allocate a holding buffer to transform the data from */
rowBuf = (GLubyte*) Xmalloc(widthsize);
if (!rowBuf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
UnlockDisplay(dpy);
SyncHandle();
return;
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)rowBuf),widthsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row);
Xfree((char*) rowBuf);
}
colBuf = (GLubyte*) Xmalloc(heightsize);
if (!colBuf) {
/* Throw data away */
_XEatData(dpy, compsize - __GLX_PAD(widthsize));
__glXSetError(gc, GL_OUT_OF_MEMORY);
UnlockDisplay(dpy);
SyncHandle();
return;
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)colBuf),heightsize);
__glEmptyImage(gc, 1, height, 1, 1, format, type, colBuf, column);
Xfree((char*) colBuf);
}
} else {
/*
** don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
const GLubyte *glGetString(GLenum name)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
GLubyte *s = NULL;
if (!dpy) return 0;
/*
** Return the cached copy if the string has already been fetched
*/
switch(name) {
case GL_VENDOR:
if (gc->vendor) return gc->vendor;
break;
case GL_RENDERER:
if (gc->renderer) return gc->renderer;
break;
case GL_VERSION:
if (gc->version) return gc->version;
break;
case GL_EXTENSIONS:
if (gc->extensions) return gc->extensions;
break;
default:
__glXSetError(gc, GL_INVALID_ENUM);
return 0;
}
/*
** Get requested string from server
*/
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetString,4);
__GLX_SINGLE_PUT_LONG(0,name);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
s = (GLubyte*) Xmalloc(compsize);
if (!s) {
/* Throw data on the floor */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(s,compsize);
/*
** Update local cache
*/
switch(name) {
case GL_VENDOR:
gc->vendor = s;
break;
case GL_RENDERER:
gc->renderer = s;
break;
case GL_VERSION: {
double server_version = strtod((char *)s, NULL);
double client_version = strtod(__glXGLClientVersion, NULL);
if ( server_version <= client_version ) {
gc->version = s;
}
else {
gc->version = Xmalloc( strlen(__glXGLClientVersion)
+ strlen((char *)s) + 4 );
if ( gc->version == NULL ) {
/* If we couldn't allocate memory for the new string,
* make a best-effort and just copy the client-side version
* to the string and use that. It probably doesn't
* matter what is done here. If there not memory available
* for a short string, the system is probably going to die
* soon anyway.
*/
strcpy((char *)s, __glXGLClientVersion);
}
else {
sprintf( (char *)gc->version, "%s (%s)",
__glXGLClientVersion, s );
Xfree( s );
s = gc->version;
}
}
break;
}
case GL_EXTENSIONS:
gc->extensions = (GLubyte *)__glXCombineExtensionStrings( (const char *)s, __glXGLClientExtensions );
XFree( s );
s = gc->extensions;
break;
}
}
__GLX_SINGLE_END();
return s;
}
void glGetIntegerv(GLenum val, GLint *i)
{
const GLenum origVal = val;
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
val = GL_MODELVIEW_MATRIX;
}
else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
val = GL_PROJECTION_MATRIX;
}
else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
val = GL_TEXTURE_MATRIX;
}
else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
val = GL_COLOR_MATRIX;
}
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
__GLX_SINGLE_PUT_LONG(0,val);
__GLX_SINGLE_READ_XREPLY();
__GLX_SINGLE_GET_SIZE(compsize);
if (compsize == 0) {
/*
** Error occured; don't modify user's buffer.
*/
} else {
/*
** For all the queries listed here, we use the locally stored
** values rather than the one returned by the server. Note that
** we still needed to send the request to the server in order to
** find out whether it was legal to make a query (it's illegal,
** for example, to call a query between glBegin() and glEnd()).
*/
switch (val) {
case GL_PACK_ROW_LENGTH:
*i = (GLint)state->storePack.rowLength;
break;
case GL_PACK_IMAGE_HEIGHT:
*i = (GLint)state->storePack.imageHeight;
break;
case GL_PACK_SKIP_ROWS:
*i = (GLint)state->storePack.skipRows;
break;
case GL_PACK_SKIP_PIXELS:
*i = (GLint)state->storePack.skipPixels;
break;
case GL_PACK_SKIP_IMAGES:
*i = (GLint)state->storePack.skipImages;
break;
case GL_PACK_ALIGNMENT:
*i = (GLint)state->storePack.alignment;
break;
case GL_PACK_SWAP_BYTES:
*i = (GLint)state->storePack.swapEndian;
break;
case GL_PACK_LSB_FIRST:
*i = (GLint)state->storePack.lsbFirst;
break;
case GL_UNPACK_ROW_LENGTH:
*i = (GLint)state->storeUnpack.rowLength;
break;
case GL_UNPACK_IMAGE_HEIGHT:
*i = (GLint)state->storeUnpack.imageHeight;
break;
case GL_UNPACK_SKIP_ROWS:
*i = (GLint)state->storeUnpack.skipRows;
break;
case GL_UNPACK_SKIP_PIXELS:
*i = (GLint)state->storeUnpack.skipPixels;
break;
case GL_UNPACK_SKIP_IMAGES:
*i = (GLint)state->storeUnpack.skipImages;
break;
case GL_UNPACK_ALIGNMENT:
*i = (GLint)state->storeUnpack.alignment;
break;
case GL_UNPACK_SWAP_BYTES:
*i = (GLint)state->storeUnpack.swapEndian;
break;
case GL_UNPACK_LSB_FIRST:
*i = (GLint)state->storeUnpack.lsbFirst;
break;
case GL_VERTEX_ARRAY:
*i = (GLint)state->vertArray.vertex.enable;
break;
case GL_VERTEX_ARRAY_SIZE:
*i = (GLint)state->vertArray.vertex.size;
break;
case GL_VERTEX_ARRAY_TYPE:
*i = (GLint)state->vertArray.vertex.type;
break;
case GL_VERTEX_ARRAY_STRIDE:
*i = (GLint)state->vertArray.vertex.stride;
break;
case GL_NORMAL_ARRAY:
*i = (GLint)state->vertArray.normal.enable;
break;
case GL_NORMAL_ARRAY_TYPE:
*i = (GLint)state->vertArray.normal.type;
break;
case GL_NORMAL_ARRAY_STRIDE:
*i = (GLint)state->vertArray.normal.stride;
break;
case GL_COLOR_ARRAY:
*i = (GLint)state->vertArray.color.enable;
break;
case GL_COLOR_ARRAY_SIZE:
*i = (GLint)state->vertArray.color.size;
break;
case GL_COLOR_ARRAY_TYPE:
*i = (GLint)state->vertArray.color.type;
break;
case GL_COLOR_ARRAY_STRIDE:
*i = (GLint)state->vertArray.color.stride;
break;
case GL_INDEX_ARRAY:
*i = (GLint)state->vertArray.index.enable;
break;
case GL_INDEX_ARRAY_TYPE:
*i = (GLint)state->vertArray.index.type;
break;
case GL_INDEX_ARRAY_STRIDE:
*i = (GLint)state->vertArray.index.stride;
break;
case GL_TEXTURE_COORD_ARRAY:
*i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].enable;
break;
case GL_TEXTURE_COORD_ARRAY_SIZE:
*i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].size;
break;
case GL_TEXTURE_COORD_ARRAY_TYPE:
*i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].type;
break;
case GL_TEXTURE_COORD_ARRAY_STRIDE:
*i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
break;
case GL_EDGE_FLAG_ARRAY:
*i = (GLint)state->vertArray.edgeFlag.enable;
break;
case GL_EDGE_FLAG_ARRAY_STRIDE:
*i = (GLint)state->vertArray.edgeFlag.stride;
break;
CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, i, GLint);
CASE_ARRAY_ENABLE(FOG_COORDINATE, fogCoord, i, GLint);
CASE_ARRAY_TYPE(FOG_COORDINATE, fogCoord, i, GLint);
CASE_ARRAY_STRIDE(FOG_COORDINATE, fogCoord, i, GLint);
case GL_MAX_ELEMENTS_VERTICES:
*i = (GLint)state->vertArray.maxElementsVertices;
break;
case GL_MAX_ELEMENTS_INDICES:
*i = (GLint)state->vertArray.maxElementsIndices;
break;
case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
*i = (GLint)__GL_CLIENT_ATTRIB_STACK_DEPTH;
break;
case GL_CLIENT_ACTIVE_TEXTURE_ARB:
*i = (GLint)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
break;
default:
/*
** Not a local value, so use what we got from the server.
*/
if (compsize == 1) {
__GLX_SINGLE_GET_LONG(i);
} else {
__GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
if (val != origVal) {
/* matrix transpose */
TransposeMatrixi(i);
}
}
}
}
__GLX_SINGLE_END();
}
