void PACK_APIENTRY crPackMap2dSWAP(GLenum target, GLdouble u1,
GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
GLint vstride, GLint vorder, const GLdouble *points)
{
unsigned char *data_ptr;
int u,v;
int comp;
GLdouble *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,
"crPackMap2d(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_SWAPPED_DOUBLE(4, u1);
WRITE_SWAPPED_DOUBLE(12, u2);
WRITE_DATA(20, GLint, SWAP32(num_components));
WRITE_DATA(24, GLint, SWAP32(uorder));
WRITE_SWAPPED_DOUBLE(28, v1);
WRITE_SWAPPED_DOUBLE(36, v2);
WRITE_DATA(44, GLint, SWAP32(num_components*uorder));
WRITE_DATA(48, GLint, SWAP32(vorder));
dest_data = (GLdouble *) (data_ptr + 52);
src_data = (GLdouble *) points;
for (v = 0 ; v < vorder ; v++)
{
for (u = 0 ; u < uorder ; u++)
{
for (comp = 0 ; comp < num_components ; comp++)
{
WRITE_SWAPPED_DOUBLE(((unsigned char *) dest_data + comp*sizeof(*points)) - data_ptr, *(src_data + comp));
}
dest_data += num_components;
src_data += ustride;
}
src_data += vstride - ustride*uorder;
}
crHugePacket(CR_MAP2D_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;
}
/**
* Convert a glDrawElements command into a sequence of ArrayElement() calls.
* NOTE: Caller must issue the glBegin/glEnd.
*/
void
crPackUnrollDrawElements(GLsizei count, GLenum type,
const GLvoid *indices)
{
int i;
switch (type) {
case GL_UNSIGNED_BYTE:
{
const GLubyte *p = (const GLubyte *) indices;
for (i = 0; i < count; i++)
crPackArrayElement(p[i]);
}
break;
case GL_UNSIGNED_SHORT:
{
const GLushort *p = (const GLushort *) indices;
for (i = 0; i < count; i++)
crPackArrayElement(p[i]);
}
break;
case GL_UNSIGNED_INT:
{
const GLuint *p = (const GLuint *) indices;
for (i = 0; i < count; i++)
crPackArrayElement(p[i]);
}
break;
default:
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM,
"crPackUnrollDrawElements(bad type)");
}
}
void PACK_APIENTRY crPackCallListsSWAP(GLint n, GLenum type,
const GLvoid *lists )
{
unsigned char *data_ptr;
int packet_length;
GLshort *shortPtr;
GLint *intPtr;
int i;
int bytesPerList = __gl_CallListsNumBytes( type );
int numBytes = bytesPerList * n;
if (numBytes < 0)
{
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
"crPackCallLists(bad type)" );
return;
}
packet_length = sizeof( n ) +
sizeof( type ) +
numBytes;
data_ptr = (unsigned char *) crPackAlloc( packet_length );
WRITE_DATA( 0, GLint, SWAP32(n) );
WRITE_DATA( 4, GLenum, SWAP32(type) );
crMemcpy( data_ptr + 8, lists, numBytes );
shortPtr = (GLshort *) (data_ptr + 8);
intPtr = (GLint *) (data_ptr + 8);
if (bytesPerList > 1)
{
for ( i = 0 ; i < n ; i++)
{
switch( bytesPerList )
{
case 2:
*shortPtr = SWAP16(*shortPtr);
shortPtr+=1;
break;
case 4:
*intPtr = SWAP32(*intPtr);
intPtr+=1;
break;
}
}
}
crHugePacket( CR_CALLLISTS_OPCODE, data_ptr );
crPackFree( data_ptr );
}
void PACK_APIENTRY crPackReadPixels(GLint x, GLint y, GLsizei width,
GLsizei height, GLenum format,
GLenum type, GLvoid *pixels,
const CRPixelPackState *packstate,
int *writeback)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
GLint stride = 0;
GLint bytes_per_row;
int bytes_per_pixel;
*writeback = 0;
bytes_per_pixel = crPixelSize(format, type);
if (bytes_per_pixel <= 0) {
char string[80];
sprintf(string, "crPackReadPixels(format 0x%x or type 0x%x)", format, type);
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM, string);
return;
}
/* default bytes_per_row so crserver can allocate memory */
bytes_per_row = width * bytes_per_pixel;
stride = bytes_per_row;
if (packstate->alignment != 1) {
GLint remainder = bytes_per_row % packstate->alignment;
if (remainder)
stride = bytes_per_row + (packstate->alignment - remainder);
}
CR_GET_BUFFERED_POINTER(pc, 48 + sizeof(CRNetworkPointer) );
WRITE_DATA( 0, GLint, x );
WRITE_DATA( 4, GLint, y );
WRITE_DATA( 8, GLsizei, width );
WRITE_DATA( 12, GLsizei, height );
WRITE_DATA( 16, GLenum, format );
WRITE_DATA( 20, GLenum, type );
WRITE_DATA( 24, GLint, stride ); /* XXX not really used! */
WRITE_DATA( 28, GLint, packstate->alignment );
WRITE_DATA( 32, GLint, packstate->skipRows );
WRITE_DATA( 36, GLint, packstate->skipPixels );
WRITE_DATA( 40, GLint, bytes_per_row );
WRITE_DATA( 44, GLint, packstate->rowLength );
WRITE_NETWORK_POINTER( 48, (char *) pixels );
WRITE_OPCODE( pc, CR_READPIXELS_OPCODE );
CR_CMDBLOCK_CHECK_FLUSH(pc);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void
crPackExpandDrawArrays(GLenum mode, GLint first, GLsizei count, CRClientState *c)
{
int i;
if (count < 0)
{
__PackError(__LINE__, __FILE__, GL_INVALID_VALUE, "crPackDrawArrays(negative count)");
return;
}
if (mode > GL_POLYGON)
{
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM, "crPackDrawArrays(bad mode)");
return;
}
crPackBegin(mode);
for (i=0; i<count; i++)
{
crPackExpandArrayElement(first + i, c);
}
crPackEnd();
}
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);
}
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, packet_length );
WRITE_DATA( 4, GLenum, pname );
WRITE_DATA( 8, GLfloat, params[0] );
if (packet_length > 12)
{
WRITE_DATA( 12, GLfloat, params[1] );
WRITE_DATA( 16, GLfloat, params[2] );
WRITE_DATA( 20, GLfloat, params[3] );
}
return GL_TRUE;
}
static GLboolean __handleCombinerParameterData( GLenum pname, const GLfloat *params, GLenum extended_opcode )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned int params_length = 0;
unsigned int packet_length = sizeof( int ) + sizeof( extended_opcode ) + sizeof( pname );
unsigned char *data_ptr;
switch( pname )
{
case GL_CONSTANT_COLOR0_NV:
case GL_CONSTANT_COLOR1_NV:
params_length = 4 * sizeof( *params );
break;
case GL_NUM_GENERAL_COMBINERS_NV:
case GL_COLOR_SUM_CLAMP_NV:
params_length = sizeof( *params );
break;
default:
__PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
"crPackCombinerParameter(bad pname)" );
CRASSERT(0);
return GL_FALSE;
}
packet_length += params_length;
CR_GET_BUFFERED_POINTER(pc, packet_length );
WRITE_DATA( 0, int, packet_length );
WRITE_DATA( sizeof( int ) + 0, GLenum, extended_opcode );
WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
if (params_length > sizeof( *params ))
{
WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
CRASSERT(packet_length == sizeof(int) + 20 + 4);
}
return GL_TRUE;
}
/**
* Expand glDrawElements into crPackBegin/Vertex/End, etc commands.
* Note: if mode==999, don't call glBegin/glEnd.
*/
void
crPackExpandDrawElements(GLenum mode, GLsizei count, GLenum type,
const GLvoid *indices, CRClientState *c)
{
int i;
GLubyte *p = (GLubyte *)indices;
#ifdef CR_ARB_vertex_buffer_object
CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer;
#endif
if (count < 0)
{
__PackError(__LINE__, __FILE__, GL_INVALID_VALUE,
"crPackDrawElements(negative count)");
return;
}
if (mode > GL_POLYGON && mode != 999)
{
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM,
"crPackDrawElements(bad mode)");
return;
}
if (type != GL_UNSIGNED_BYTE &&
type != GL_UNSIGNED_SHORT &&
type != GL_UNSIGNED_INT)
{
__PackError(__LINE__, __FILE__, GL_INVALID_ENUM,
"crPackDrawElements(bad type)");
return;
}
#ifdef CR_ARB_vertex_buffer_object
if (elementsBuffer && elementsBuffer->data)
{
p = (unsigned char *)(elementsBuffer->data) + (unsigned long)p;
}
#endif
if (mode != 999)
crPackBegin(mode);
//crDebug("crPackExpandDrawElements mode:0x%x, count:%d, type:0x%x", mode, count, type);
switch (type)
{
case GL_UNSIGNED_BYTE:
for (i=0; i<count; i++)
{
crPackExpandArrayElement((GLint) *p++, c);
}
break;
case GL_UNSIGNED_SHORT:
for (i=0; i<count; i++)
{
crPackExpandArrayElement((GLint) * (GLushort *) p, c);
p+=sizeof (GLushort);
}
break;
case GL_UNSIGNED_INT:
for (i=0; i<count; i++)
{
crPackExpandArrayElement((GLint) * (GLuint *) p, c);
p+=sizeof (GLuint);
}
break;
default:
crError( "this can't happen: array_spu.self.DrawElements" );
break;
}
if (mode != 999)
crPackEnd();
}
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;
}
