void PACK_APIENTRY crPackMap2fSWAP(GLenum target, GLfloat u1,
GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
GLint vstride, GLint vorder, const GLfloat *points)
{
unsigned char *data_ptr;
int u,v;
int comp;
GLfloat *dest_data, *src_data;
int packet_length =
sizeof(target) +
sizeof(u1) +
sizeof(u2) +
sizeof(uorder) +
sizeof(ustride) +
sizeof(v1) +
sizeof(v2) +
sizeof(vorder) +
sizeof(vstride);
int num_components = __gl_Map2NumComponents(target);
if (num_components < 0)
{
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM,
"crPackMap2f(bad target)");
return;
}
packet_length += num_components*uorder*vorder*sizeof(*points);
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA(0, GLenum, SWAP32(target));
WRITE_DATA(4, GLuint, SWAPFLOAT(u1));
WRITE_DATA(8, GLuint, SWAPFLOAT(u2));
WRITE_DATA(12, GLint, SWAP32(num_components));
WRITE_DATA(16, GLint, SWAP32(uorder));
WRITE_DATA(20, GLuint, SWAPFLOAT(v1));
WRITE_DATA(24, GLuint, SWAPFLOAT(v2));
WRITE_DATA(28, GLint, SWAP32(num_components*uorder));
WRITE_DATA(32, GLint, SWAP32(vorder));
dest_data = (GLfloat *) (data_ptr + 36);
src_data = (GLfloat *) points;
for (v = 0 ; v < vorder ; v++)
{
for (u = 0 ; u < uorder ; u++)
{
for (comp = 0 ; comp < num_components ; comp++)
{
WRITE_DATA((unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT(*(src_data + comp)));
}
dest_data += num_components;
src_data += ustride;
}
src_data += vstride - ustride*uorder;
}
crHugePacket(CR_MAP2F_OPCODE, data_ptr);
crPackFree(data_ptr);
}
static GLboolean __handleLightModelData( GLenum pname, const GLfloat *params )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned int packet_length = sizeof( int ) + sizeof( pname );
unsigned int params_length = 0;
unsigned char *data_ptr;
switch( pname )
{
case GL_LIGHT_MODEL_AMBIENT:
params_length = 4*sizeof( *params );
break;
case GL_LIGHT_MODEL_TWO_SIDE:
case GL_LIGHT_MODEL_LOCAL_VIEWER:
params_length = sizeof( *params );
break;
default:
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
"crPackLightModelSWAP(bad pname)" );
return GL_FALSE;
}
packet_length += params_length;
CR_GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, SWAP32(packet_length) );
WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(pname) );
WRITE_DATA( sizeof( int ) + 4, GLuint, SWAPFLOAT(params[0]) );
if (params_length > sizeof( *params ))
{
WRITE_DATA( sizeof( int ) + 8, GLuint, SWAPFLOAT(params[1]) );
WRITE_DATA( sizeof( int ) + 12, GLuint, SWAPFLOAT(params[2]) );
WRITE_DATA( sizeof( int ) + 16, GLuint, SWAPFLOAT(params[3]) );
}
return GL_TRUE;
}
void PACK_APIENTRY crPackMap1fSWAP(GLenum target, GLfloat u1,
GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
unsigned char *data_ptr;
int packet_length =
sizeof(target) +
sizeof(u1) +
sizeof(u2) +
sizeof(stride) +
sizeof(order);
int num_components = __gl_Map1NumComponents(target);
GLfloat *src_data, *dest_data;
int u;
int comp;
if (num_components < 0)
{
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM,
"crPackMap1f(bad target)");
return;
}
packet_length += num_components * order * sizeof(*points);
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA(0, GLenum, SWAP32(target));
WRITE_DATA(4, GLuint, SWAPFLOAT(u1));
WRITE_DATA(8, GLuint, SWAPFLOAT(u2));
WRITE_DATA(12, GLint, SWAP32(num_components));
WRITE_DATA(16, GLint, SWAP32(order));
dest_data = (GLfloat *) (data_ptr + 20);
src_data = (GLfloat *) points;
for (u = 0 ; u < order ; u++)
{
for (comp = 0 ; comp < num_components ; comp++)
{
WRITE_DATA((unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT(*(src_data + comp)));
}
dest_data += num_components;
src_data += stride;
}
crHugePacket(CR_MAP1F_OPCODE, data_ptr);
crPackFree(data_ptr);
}
void PACK_APIENTRY crPackPrioritizeTexturesSWAP( GLsizei n,
const GLuint *textures, const GLclampf *priorities )
{
unsigned char *data_ptr;
int packet_length =
sizeof( n ) +
n*sizeof( *textures ) +
n*sizeof( *priorities );
int i;
data_ptr = (unsigned char *) crPackAlloc( packet_length );
WRITE_DATA( 0, GLsizei, SWAP32(n) );
for ( i = 0 ; i < n ; i++)
{
WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]));
}
for ( i = 0 ; i < n ; i++)
{
WRITE_DATA( i*sizeof(int) + 4 + n*sizeof( *textures ),
GLuint, SWAPFLOAT(priorities[i]));
}
crHugePacket( CR_PRIORITIZETEXTURES_OPCODE, data_ptr );
crPackFree( data_ptr );
}
static void __handleTexEnvData( GLenum target, GLenum pname, const GLfloat *params )
{
GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int num_params;
int i;
int packet_length =
sizeof( int ) +
sizeof( target ) +
sizeof( pname );
num_params = 1;
if ( pname == GL_TEXTURE_ENV_COLOR )
{
num_params = 4;
}
packet_length += num_params*sizeof(*params);
GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, SWAP32(packet_length) );
WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
for ( i = 0 ; i < num_params ; i++)
{
WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT( params[i] ) );
}
}
static GLboolean __handleLightData( GLenum light, GLenum pname, const GLfloat *params )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned int packet_length = sizeof( int ) + sizeof( light ) + sizeof( pname );
unsigned int params_length = 0;
unsigned char *data_ptr;
switch( pname )
{
case GL_AMBIENT:
case GL_DIFFUSE:
case GL_SPECULAR:
case GL_POSITION:
params_length = 4*sizeof( *params );
break;
case GL_SPOT_DIRECTION:
params_length = 3*sizeof( *params );
break;
case GL_SPOT_EXPONENT:
case GL_SPOT_CUTOFF:
case GL_CONSTANT_ATTENUATION:
case GL_LINEAR_ATTENUATION:
case GL_QUADRATIC_ATTENUATION:
params_length = sizeof( *params );
break;
default:
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
"crPackLightSWAP(bad pname)" );
return GL_FALSE;
}
packet_length += params_length;
CR_GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, SWAP32(packet_length) );
WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(light) );
WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
WRITE_DATA( sizeof( int ) + 8, GLuint, SWAPFLOAT(params[0]) );
if (params_length > sizeof( *params ))
{
WRITE_DATA( sizeof( int ) + 12, GLuint, SWAPFLOAT(params[1]) );
WRITE_DATA( sizeof( int ) + 16, GLuint, SWAPFLOAT(params[2]) );
}
if (params_length > 3*sizeof( *params ))
{
WRITE_DATA( sizeof( int ) + 20, GLuint, SWAPFLOAT(params[3]) );
}
return GL_TRUE;
}
static GLboolean __handleFogData( GLenum pname, const GLfloat *params )
{
GET_PACKER_CONTEXT(pc);
int params_length = 0;
int packet_length = sizeof( int ) + sizeof( pname );
unsigned char *data_ptr;
switch( pname )
{
case GL_FOG_MODE:
case GL_FOG_DENSITY:
case GL_FOG_START:
case GL_FOG_END:
case GL_FOG_INDEX:
params_length = sizeof( *params );
break;
case GL_FOG_COLOR:
params_length = 4*sizeof( *params );
break;
default:
params_length = __packFogParamsLength( pname );
if (!params_length)
{
char msg[100];
sprintf(msg, "Invalid pname in Fog: %d", (int) pname );
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
return GL_FALSE;
}
break;
}
packet_length += params_length;
GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, SWAP32(packet_length) );
WRITE_DATA( 4, GLenum, SWAP32(pname) );
WRITE_DATA( 8, GLuint, SWAPFLOAT(params[0]) );
if (packet_length > 12)
{
WRITE_DATA( 12, GLuint, SWAPFLOAT(params[1]) );
WRITE_DATA( 16, GLuint, SWAPFLOAT(params[2]) );
WRITE_DATA( 20, GLuint, SWAPFLOAT(params[3]) );
}
return GL_TRUE;
}
static void hoare_select_f (float *f, int i0, int i1, int q)
{
float pivot = PERM(i0);
int j0, j1, lim;
assert (i1 - i0 > 1 && q > i0 && q < i1);
for (j0 = i0, j1 = i1 ; 1 ; ) {
while (j0 < j1 - 1) {
j0++;
if (PERM(j0) > pivot)
goto endseginf;
}
lim = j1;
break;
endseginf:
while (j1 - 1 > j0) {
j1--;
if (PERM(j1) <= pivot)
goto endsegsup;
}
lim = j0;
break;
endsegsup:
SWAPFLOAT (j0, j1);
}
assert (lim > i0);
if (lim == i1) {
SWAPFLOAT (i0, i1 - 1);
lim = i1 - 1;
}
if (lim == q)
return; /* mission accomplished */
if (q < lim)
hoare_select_f (f, i0, lim, q);
else
hoare_select_f (f, lim, i1, q);
}
static GLboolean __handleTexParameterData( GLenum target, GLenum pname, const GLfloat *params )
{
GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = sizeof( int ) + sizeof( target ) + sizeof( pname );
int num_params = 0;
int i;
switch( pname )
{
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
#ifdef GL_TEXTURE_PRIORITY
case GL_TEXTURE_PRIORITY:
#endif
num_params = 1;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
num_params = 1;
break;
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MAX_LEVEL:
num_params = 1;
break;
case GL_TEXTURE_BORDER_COLOR:
num_params = 4;
break;
#ifdef CR_ARB_shadow
case GL_TEXTURE_COMPARE_MODE_ARB:
case GL_TEXTURE_COMPARE_FUNC_ARB:
num_params = 1;
break;
#endif
#ifdef CR_ARB_shadow_ambient
case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
num_params = 1;
break;
#endif
#ifdef CR_ARB_depth_texture
case GL_DEPTH_TEXTURE_MODE_ARB:
num_params = 1;
break;
#endif
#ifdef CR_SGIS_generate_mipmap
case GL_GENERATE_MIPMAP_SGIS:
num_params = 1;
break;
#endif
default:
num_params = __packTexParameterNumParams( pname );
if (!num_params)
{
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
"crPackTexParameter(bad pname)" );
return GL_FALSE;
}
}
packet_length += num_params * sizeof(*params);
GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, SWAP32(packet_length) );
WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
for ( i = 0 ; i < num_params ; i++)
{
WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT(params[i]) );
}
return GL_TRUE;
}
