int crdlm_pointers_CompressedTexImage3DARB(struct instanceCompressedTexImage3DARB *instance, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid *data)
{
unsigned int size = imagesize;
if (instance && size > 0) {
crMemcpy(instance->data, data, size);
}
return size;
}
void crUnpackClipPlane(PCrUnpackerState pState)
{
GLdouble equation[4];
CHECK_BUFFER_SIZE_STATIC(pState, 4 + sizeof(equation));
GLenum plane = READ_DATA(pState, 0, GLenum );
crMemcpy( equation, DATA_POINTER(pState, 4, GLdouble ), sizeof(equation) );
pState->pDispatchTbl->ClipPlane( plane, equation );
INCR_DATA_PTR(pState, sizeof( GLenum ) + 4*sizeof( GLdouble ));
}
void STATE_APIENTRY
crStateBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data)
{
CRContext *g = GetCurrentContext();
CRBufferObjectState *b = &g->bufferobject;
CRBufferObject *obj;
CRStateBits *sb = GetCurrentBits();
CRBufferObjectBits *bb = &sb->bufferobject;
FLUSH();
if (g->current.inBeginEnd) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glBufferSubDataARB called in begin/end");
return;
}
obj = crStateGetBoundBufferObject(target, b);
if (!obj)
{
crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "glBufferSubDataARB(target)");
return;
}
if (obj->id == 0) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glBufferSubDataARB");
return;
}
if (obj->pointer) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glBufferSubDataARB(buffer is mapped)");
return;
}
if (size < 0 || offset < 0 || (unsigned int)offset + size > obj->size) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glBufferSubDataARB(bad offset and/or size)");
return;
}
if (b->retainBufferData && obj->data) {
crMemcpy((char *) obj->data + offset, data, size);
}
DIRTY(bb->dirty, g->neg_bitid);
DIRTY(obj->dirty, g->neg_bitid);
/* grow dirty region */
if (offset + size > obj->dirtyStart + obj->dirtyLength)
obj->dirtyLength = offset + size;
if (offset < obj->dirtyStart)
obj->dirtyStart = offset;
}
int crdlm_pointers_ZPixCR( struct instanceZPixCR *instance, GLsizei width,
GLsizei height, GLenum format, GLenum type,
GLenum ztype, GLint zparm, GLint length,
const GLvoid *pixels, CRClientState *c)
{
unsigned int size = length;
if (instance && size > 0) {
crMemcpy(instance->pixels,pixels,length);
}
return size;
}
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 crUnpackExtendProgramNamedParameter4fvNV(void)
{
GLenum id = READ_DATA(8, GLuint);
GLsizei len = READ_DATA(12, GLsizei);
GLfloat params[4];
GLubyte *name = crAlloc(len);
params[0] = READ_DATA(16, GLfloat);
params[1] = READ_DATA(20, GLfloat);
params[2] = READ_DATA(24, GLfloat);
params[3] = READ_DATA(28, GLfloat);
crMemcpy(name, DATA_POINTER(32, GLubyte), len);
cr_unpackDispatch.ProgramNamedParameter4fvNV(id, len, name, params);
}
void crUnpackExtendProgramNamedParameter4dNV(void)
{
GLuint id = READ_DATA(8, GLuint);
GLsizei len = READ_DATA(12, GLsizei);
GLdouble params[4];
GLubyte *name = crAlloc (len);
params[0] = READ_DOUBLE(16);
params[1] = READ_DOUBLE(24);
params[2] = READ_DOUBLE(32);
params[3] = READ_DOUBLE(40);
crMemcpy(name, DATA_POINTER(48, GLubyte), len);
cr_unpackDispatch.ProgramNamedParameter4dNV(id, len, name, params[0], params[1], params[2], params[3]);
}
void PACK_APIENTRY crPackCompressedTexSubImage3DARBSWAP( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imagesize, const GLvoid *data )
{
unsigned char *data_ptr;
int packet_length;
int isnull = (data == NULL);
/* All extended opcodes have their first 8 bytes predefined:
* the first four indicate the packet size, and the next four
* indicate the actual extended opcode.
*/
packet_length =
sizeof( GLenum) + /* extended opcode */
sizeof( target ) +
sizeof( level ) +
sizeof( xoffset ) +
sizeof( yoffset ) +
sizeof( zoffset ) +
sizeof( width ) +
sizeof( height ) +
sizeof( depth ) +
sizeof( format ) +
sizeof( imagesize ) +
sizeof( int ); /* isnull */
if (data)
{
packet_length += imagesize;
}
data_ptr = (unsigned char *) crPackAlloc( packet_length );
WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE3DARB_EXTEND_OPCODE) );
WRITE_DATA( 4, GLenum, SWAP32(target) );
WRITE_DATA( 8, GLint, SWAP32(level) );
WRITE_DATA( 12, GLint, SWAP32(xoffset) );
WRITE_DATA( 16, GLint, SWAP32(yoffset) );
WRITE_DATA( 20, GLint, SWAP32(zoffset) );
WRITE_DATA( 24, GLsizei, SWAP32(width) );
WRITE_DATA( 28, GLsizei, SWAP32(height) );
WRITE_DATA( 32, GLsizei, SWAP32(depth) );
WRITE_DATA( 36, GLenum, SWAP32(format) );
WRITE_DATA( 40, GLsizei, SWAP32(imagesize) );
WRITE_DATA( 44, int, SWAP32(isnull) );
if (data) {
crMemcpy( (void *)(data_ptr + 48), (void *)data, imagesize);
}
crHugePacket( CR_EXTEND_OPCODE, data_ptr );
crPackFree( data_ptr );
}
void PACK_APIENTRY crPackDrawBuffers(GLsizei n, const GLenum *bufs)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(n) + n*sizeof(*bufs);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_DRAWBUFFERS_EXTEND_OPCODE);
WRITE_DATA_AI(GLsizei, n);
crMemcpy(data_ptr, bufs, n*sizeof(*bufs));
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void STATE_APIENTRY crStateGetPolygonStipple(PCRStateTracker pState, GLubyte *b )
{
CRContext *g = GetCurrentContext(pState);
CRPolygonState *poly = &(g->polygon);
if (g->current.inBeginEnd)
{
crStateError(pState, __LINE__, __FILE__, GL_INVALID_OPERATION,
"glGetPolygonStipple called in begin/end");
return;
}
crMemcpy((char*)b, (char*)poly->stipple, 128);
}
void crPackAppendBuffer( const CRPackBuffer *src )
{
GET_PACKER_CONTEXT(pc);
const int num_data = crPackNumData(src);
const int num_opcode = crPackNumOpcodes(src);
CRASSERT(num_data >= 0);
CRASSERT(num_opcode >= 0);
/* don't append onto ourself! */
CRASSERT(pc->currentBuffer);
CRASSERT(pc->currentBuffer != src);
if (!crPackCanHoldBuffer(src))
{
if (src->holds_BeginEnd)
{
crWarning( "crPackAppendBuffer: overflowed the destination!" );
return;
}
else
crError( "crPackAppendBuffer: overflowed the destination!" );
}
/* Copy the buffer data/operands which are at the head of the buffer */
crMemcpy( pc->buffer.data_current, src->data_start, num_data );
pc->buffer.data_current += num_data;
/* Copy the buffer opcodes which are at the tail of the buffer */
CRASSERT( pc->buffer.opcode_current - num_opcode >= pc->buffer.opcode_end );
crMemcpy( pc->buffer.opcode_current + 1 - num_opcode, src->opcode_current + 1,
num_opcode );
pc->buffer.opcode_current -= num_opcode;
pc->buffer.holds_BeginEnd |= src->holds_BeginEnd;
pc->buffer.in_BeginEnd = src->in_BeginEnd;
pc->buffer.holds_List |= src->holds_List;
}
void PACK_APIENTRY crPackDeleteProgramsARB(GLsizei n, const GLuint *ids)
{
unsigned char *data_ptr;
int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*ids);
if (!ids)
return;
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA(0, GLenum, CR_DELETEPROGRAMSARB_EXTEND_OPCODE);
WRITE_DATA(4, GLsizei, n);
crMemcpy(data_ptr + 8, ids, n * sizeof(*ids));
crHugePacket(CR_EXTEND_OPCODE, data_ptr);
crPackFree(data_ptr);
}
void PACK_APIENTRY crPackUniform4iv(GLint location, GLsizei count, const GLint *value)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(location)+sizeof(count) + 4*count*sizeof(*value);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_UNIFORM4IV_EXTEND_OPCODE);
WRITE_DATA_AI(GLint, location);
WRITE_DATA_AI(GLsizei, count);
crMemcpy(data_ptr, value, 4*count*sizeof(*value));
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void crUnpackTexGendv( void )
{
GLenum coord = READ_DATA( sizeof( int ) + 0, GLenum );
GLenum pname = READ_DATA( sizeof( int ) + 4, GLenum );
GLdouble params[4];
unsigned int n_param = READ_DATA( 0, int ) - ( sizeof(int) + 8 );
if ( n_param > sizeof(params) )
crError( "crUnpackTexGendv: n_param=%d, expected <= %d\n", n_param,
(unsigned int)sizeof(params) );
crMemcpy( params, DATA_POINTER( sizeof( int ) + 8, GLdouble ), n_param );
cr_unpackDispatch.TexGendv( coord, pname, params );
INCR_VAR_PTR();
}
void crNetworkPointerWrite( CRNetworkPointer *dst, void *src )
{
/* init CRNetworkPointer with invalid values */
dst->ptrAlign[0] = 0xDeadBeef;
dst->ptrAlign[1] = 0xCafeBabe;
/* copy the pointer's value into the CRNetworkPointer */
crMemcpy( dst, &src, sizeof(src) );
/* if either assertion fails, it probably means that a packer function
* (which returns a value) was called without setting up the writeback
* pointer, or something like that.
*/
CRASSERT(dst->ptrAlign[0] != 0xffffffff);
CRASSERT(dst->ptrAlign[0] != 0xDeadBeef);
}
void PACK_APIENTRY
crPackDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
GLenum type, const GLvoid *indices)
{
unsigned char *data_ptr, *start_ptr;
int packet_length = sizeof(int) + sizeof(mode) + sizeof(start)
+ sizeof(end) + sizeof(count) + sizeof(type) + sizeof(GLuint);
GLsizei indexsize;
#ifdef CR_ARB_vertex_buffer_object
CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer;
packet_length += sizeof(GLint);
if (elementsBuffer && elementsBuffer->id)
{
/*@todo not sure it's possible, and not sure what to do*/
if (!elementsBuffer->data)
{
crWarning("crPackDrawElements: trying to use bound but empty elements buffer, ignoring.");
return;
}
indexsize = 0;
}
else
#endif
{
indexsize = crPackElementsIndexSize(type);
}
packet_length += count * indexsize;
start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA_AI(GLenum, CR_DRAWRANGEELEMENTS_EXTEND_OPCODE);
WRITE_DATA_AI(GLenum, mode);
WRITE_DATA_AI(GLuint, start);
WRITE_DATA_AI(GLuint, end);
WRITE_DATA_AI(GLsizei, count);
WRITE_DATA_AI(GLenum, type);
WRITE_DATA_AI(GLuint, (GLuint) ((uintptr_t) indices));
#ifdef CR_ARB_vertex_buffer_object
WRITE_DATA_AI(GLint, (GLint) (indexsize>0));
#endif
if (indexsize>0)
{
crMemcpy(data_ptr, indices, count * indexsize);
}
crHugePacket(CR_EXTEND_OPCODE, start_ptr);
crPackFree(start_ptr);
}
void PACK_APIENTRY
crPackDeleteBuffersARBSWAP(GLsizei n, const GLuint * buffers)
{
unsigned char *data_ptr;
int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*buffers);
if (!buffers)
return;
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA( 0, GLenum, SWAP32(CR_DELETEBUFFERSARB_EXTEND_OPCODE) );
WRITE_DATA( 4, GLsizei, SWAP32(n) );
crMemcpy( data_ptr + 8, buffers, n * sizeof(*buffers) );
crHugePacket( CR_EXTEND_OPCODE, data_ptr );
crPackFree( data_ptr );
}
void PACK_APIENTRY
crPackDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
{
unsigned char *data_ptr;
int packet_length = sizeof(GLenum) + sizeof(n) + n*sizeof(*framebuffers);
if (!framebuffers)
return;
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA(0, GLenum, CR_DELETEFRAMEBUFFERSEXT_EXTEND_OPCODE);
WRITE_DATA(4, GLsizei, n);
crMemcpy(data_ptr + 8, framebuffers, n* sizeof(*framebuffers));
crHugePacket(CR_EXTEND_OPCODE, data_ptr);
crPackFree(data_ptr);
}
void PACK_APIENTRY crPackLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program)
{
const int packet_length = 20 + len;
unsigned char *data_ptr;
CR_GET_PACKER_CONTEXT(pc);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, int, packet_length);
WRITE_DATA(4, GLenum, CR_LOADPROGRAMNV_EXTEND_OPCODE);
WRITE_DATA(8, GLenum, target);
WRITE_DATA(12, GLuint, id);
WRITE_DATA(16, GLsizei, len);
crMemcpy((void *) (data_ptr + 20), program, len);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string)
{
const int packet_length = 20 + len;
unsigned char *data_ptr;
CR_GET_PACKER_CONTEXT(pc);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, int, packet_length);
WRITE_DATA(4, GLenum, CR_PROGRAMSTRINGARB_EXTEND_OPCODE);
WRITE_DATA(8, GLenum, target);
WRITE_DATA(12, GLuint, format);
WRITE_DATA(16, GLsizei, len);
crMemcpy((void *) (data_ptr + 20), string, len);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLfloat);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, int, packet_length);
WRITE_DATA(sizeof(int) + 0, GLenum, target);
WRITE_DATA(sizeof(int) + 4, GLuint, index);
WRITE_DATA(sizeof(int) + 8, GLuint, num);
crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLfloat));
WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4FVNV_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(location)+sizeof(count)+sizeof(transpose) + 3*3*count*sizeof(*value);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_UNIFORMMATRIX3FV_EXTEND_OPCODE);
WRITE_DATA_AI(GLint, location);
WRITE_DATA_AI(GLsizei, count);
WRITE_DATA_AI(GLboolean, transpose);
crMemcpy(data_ptr, value, 3*3*count*sizeof(*value));
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackBindAttribLocation(GLuint program, GLuint index, const char *name)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int cbName = crStrlen(name)+1;
int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(program)+sizeof(index) + cbName*sizeof(*name);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_BINDATTRIBLOCATION_EXTEND_OPCODE);
WRITE_DATA_AI(GLuint, program);
WRITE_DATA_AI(GLuint, index);
crMemcpy(data_ptr, name, cbName*sizeof(*name));
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
char *crStrdup( const char *str )
{
int len;
char *ret;
/* Allow strdup'ing of NULL strings -- this makes the __fillin functions
* much cleaner. */
if (str == NULL) return NULL;
len = crStrlen(str);
ret = (char*)crAlloc( len+1 );
crMemcpy( ret, str, len );
ret[len] = '\0';
return ret;
}
void
CRUT_APIENTRY
crutGetMenuXML( CRUTAPI *crut_api )
{
char response[8096];
if (!crut_api->mothershipConn)
crError("Checking for Menu XML but no connection!");
crMothershipGetParam( crut_api->mothershipConn, "crut_menu_xml", response );
if (crStrlen(response) < MENU_MAX_SIZE)
crMemcpy(crut_api->menuBuffer, response, crStrlen(response));
else
crError("Menu XML is too long for buffer");
}
void PACK_APIENTRY
crPackDeleteFencesNV(GLsizei n, const GLuint * fences)
{
unsigned char *data_ptr;
int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*fences);
if( !fences )
return;
data_ptr = (unsigned char *) crPackAlloc(packet_length);
WRITE_DATA(0, GLenum, CR_DELETEFENCESNV_EXTEND_OPCODE);
WRITE_DATA(4, GLsizei, n);
crMemcpy(data_ptr + 8, fences, n * sizeof(*fences));
crHugePacket(CR_EXTEND_OPCODE, data_ptr);
crPackFree(data_ptr);
}
/**
* Receive a chunk of a CR_MESSAGE_MULTI_BODY/TAIL transmission.
* \param conn the network connection
* \param msg the incoming multi-part message
* \param len number of bytes in the message
*/
static void
crNetRecvMulti( CRConnection *conn, CRMessageMulti *msg, unsigned int len )
{
CRMultiBuffer *multi = &(conn->multi);
unsigned char *src, *dst;
CRASSERT( len > sizeof(*msg) );
len -= sizeof(*msg);
/* Check if there's enough room in the multi-buffer to append 'len' bytes */
if ( len + multi->len > multi->max )
{
if ( multi->max == 0 )
{
multi->len = conn->sizeof_buffer_header;
multi->max = 8192; /* arbitrary initial size */
}
/* grow the buffer by 2x until it's big enough */
while ( len + multi->len > multi->max )
{
multi->max <<= 1;
}
crRealloc( &multi->buf, multi->max );
}
dst = (unsigned char *) multi->buf + multi->len;
src = (unsigned char *) msg + sizeof(*msg);
crMemcpy( dst, src, len );
multi->len += len;
if (msg->header.type == CR_MESSAGE_MULTI_TAIL)
{
/* OK, we've collected the last chunk of the multi-part message */
conn->HandleNewMessage(
conn,
(CRMessage *) (((char *) multi->buf) + conn->sizeof_buffer_header),
multi->len - conn->sizeof_buffer_header );
/* clean this up before calling the user */
multi->buf = NULL;
multi->len = 0;
multi->max = 0;
}
/* Don't do this too early! */
conn->InstantReclaim( conn, (CRMessage *) msg );
}
/*
ZPix - compressed DrawPixels
*/
void PACK_APIENTRY crPackZPixCR( GLsizei width, GLsizei height,
GLenum format, GLenum type,
GLenum ztype, GLint zparm, GLint length,
const GLvoid *pixels,
const CRPixelPackState *unpackstate )
{
unsigned char *data_ptr;
int packet_length;
(void)unpackstate;
if (pixels == NULL)
{
return;
}
packet_length =
sizeof( int ) + /* packet size */
sizeof( GLenum ) + /* extended opcode */
sizeof( width ) +
sizeof( height ) +
sizeof( format ) +
sizeof( type ) +
sizeof( ztype ) +
sizeof( zparm ) +
sizeof( length );
packet_length += length;
/* XXX JAG
crDebug("PackZPixCR: fb %d x %d, state %d, zlen = %d, plen = %d",
width, height, ztype, length, packet_length);
*/
data_ptr = (unsigned char *) crPackAlloc( packet_length );
WRITE_DATA( 0, GLenum , CR_ZPIXCR_EXTEND_OPCODE );
WRITE_DATA( 4, GLsizei, width );
WRITE_DATA( 8, GLsizei, height );
WRITE_DATA( 12, GLenum, format );
WRITE_DATA( 16, GLenum, type );
WRITE_DATA( 20, GLenum, ztype );
WRITE_DATA( 24, GLint, zparm );
WRITE_DATA( 28, GLint, length );
crMemcpy((void *) (data_ptr+32), pixels, length);
crHugePacket( CR_EXTEND_OPCODE, data_ptr );
crPackFree( data_ptr );
}
int crdlm_pointers_Lightfv( struct instanceLightfv *instance, GLenum light, GLenum pname, const GLfloat *params )
{
unsigned int size;
switch(pname) {
case GL_AMBIENT: case GL_DIFFUSE: case GL_SPECULAR: case GL_POSITION:
size = 4 * sizeof(GLfloat);
break;
case GL_SPOT_DIRECTION:
size = 3 * sizeof(GLfloat);
break;
default:
size = 1 * sizeof(GLfloat);
break;
}
if (instance) crMemcpy(instance->params, params, size);
return size;
}
static void crServerCopySubImage(char *pDst, char* pSrc, CRrecti *pRect, int srcWidth, int srcHeight)
{
int i;
int dstrowsize = 4*(pRect->x2-pRect->x1);
int srcrowsize = 4*srcWidth;
int height = pRect->y2-pRect->y1;
pSrc += 4*pRect->x1 + srcrowsize*(srcHeight-1-pRect->y1);
for (i=0; i<height; ++i)
{
crMemcpy(pDst, pSrc, dstrowsize);
pSrc -= srcrowsize;
pDst += dstrowsize;
}
}
