自学教程：C++ CR_UNLOCK_PACKER_CONTEXT函数代码示例

void PACK_APIENTRY crPackLoadTransposeMatrixfARB( const GLfloat *m ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);    CR_GET_BUFFERED_POINTER(pc, packet_length );    WRITE_DATA( 0, GLint, packet_length );    WRITE_DATA( 4, GLenum, CR_LOADTRANSPOSEMATRIXFARB_EXTEND_OPCODE );    WRITE_DATA( 8 + 0*sizeof(GLfloat), GLfloat, m[ 0] );    WRITE_DATA( 8 + 1*sizeof(GLfloat), GLfloat, m[ 1] );    WRITE_DATA( 8 + 2*sizeof(GLfloat), GLfloat, m[ 2] );    WRITE_DATA( 8 + 3*sizeof(GLfloat), GLfloat, m[ 3] );    WRITE_DATA( 8 + 4*sizeof(GLfloat), GLfloat, m[ 4] );    WRITE_DATA( 8 + 5*sizeof(GLfloat), GLfloat, m[ 5] );    WRITE_DATA( 8 + 6*sizeof(GLfloat), GLfloat, m[ 6] );    WRITE_DATA( 8 + 7*sizeof(GLfloat), GLfloat, m[ 7] );    WRITE_DATA( 8 + 8*sizeof(GLfloat), GLfloat, m[ 8] );    WRITE_DATA( 8 + 9*sizeof(GLfloat), GLfloat, m[ 9] );    WRITE_DATA( 8 + 10*sizeof(GLfloat), GLfloat, m[10] );    WRITE_DATA( 8 + 11*sizeof(GLfloat), GLfloat, m[11] );    WRITE_DATA( 8 + 12*sizeof(GLfloat), GLfloat, m[12] );    WRITE_DATA( 8 + 13*sizeof(GLfloat), GLfloat, m[13] );    WRITE_DATA( 8 + 14*sizeof(GLfloat), GLfloat, m[14] );    WRITE_DATA( 8 + 15*sizeof(GLfloat), GLfloat, m[15] );    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackLightfvSWAP (GLenum light, GLenum pname, const GLfloat *params){    CR_GET_PACKER_CONTEXT(pc);    if (__handleLightData( light, pname, params ))        WRITE_OPCODE( pc, CR_LIGHTFV_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackCombinerParameterfvNV( GLenum pname, const GLfloat *params ){    CR_GET_PACKER_CONTEXT(pc);    if (__handleCombinerParameterData( pname, params, CR_COMBINERPARAMETERFVNV_EXTEND_OPCODE ))        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackLoadMatrixf( const GLfloat *m ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    int packet_length = 16*sizeof( *m );    CR_GET_BUFFERED_POINTER(pc, packet_length );    WRITE_DATA( 0*sizeof(GLfloat), GLfloat, m[ 0] );    WRITE_DATA( 1*sizeof(GLfloat), GLfloat, m[ 1] );    WRITE_DATA( 2*sizeof(GLfloat), GLfloat, m[ 2] );    WRITE_DATA( 3*sizeof(GLfloat), GLfloat, m[ 3] );    WRITE_DATA( 4*sizeof(GLfloat), GLfloat, m[ 4] );    WRITE_DATA( 5*sizeof(GLfloat), GLfloat, m[ 5] );    WRITE_DATA( 6*sizeof(GLfloat), GLfloat, m[ 6] );    WRITE_DATA( 7*sizeof(GLfloat), GLfloat, m[ 7] );    WRITE_DATA( 8*sizeof(GLfloat), GLfloat, m[ 8] );    WRITE_DATA( 9*sizeof(GLfloat), GLfloat, m[ 9] );    WRITE_DATA( 10*sizeof(GLfloat), GLfloat, m[10] );    WRITE_DATA( 11*sizeof(GLfloat), GLfloat, m[11] );    WRITE_DATA( 12*sizeof(GLfloat), GLfloat, m[12] );    WRITE_DATA( 13*sizeof(GLfloat), GLfloat, m[13] );    WRITE_DATA( 14*sizeof(GLfloat), GLfloat, m[14] );    WRITE_DATA( 15*sizeof(GLfloat), GLfloat, m[15] );    WRITE_OPCODE( pc, CR_LOADMATRIXF_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackMultMatrixd( const GLdouble *m ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    int packet_length = 16*sizeof( *m );    CR_GET_BUFFERED_POINTER(pc, packet_length );    WRITE_DOUBLE( 0*sizeof(double), m[ 0] );    WRITE_DOUBLE( 1*sizeof(double), m[ 1] );    WRITE_DOUBLE( 2*sizeof(double), m[ 2] );    WRITE_DOUBLE( 3*sizeof(double), m[ 3] );    WRITE_DOUBLE( 4*sizeof(double), m[ 4] );    WRITE_DOUBLE( 5*sizeof(double), m[ 5] );    WRITE_DOUBLE( 6*sizeof(double), m[ 6] );    WRITE_DOUBLE( 7*sizeof(double), m[ 7] );    WRITE_DOUBLE( 8*sizeof(double), m[ 8] );    WRITE_DOUBLE( 9*sizeof(double), m[ 9] );    WRITE_DOUBLE( 10*sizeof(double), m[10] );    WRITE_DOUBLE( 11*sizeof(double), m[11] );    WRITE_DOUBLE( 12*sizeof(double), m[12] );    WRITE_DOUBLE( 13*sizeof(double), m[13] );    WRITE_DOUBLE( 14*sizeof(double), m[14] );    WRITE_DOUBLE( 15*sizeof(double), m[15] );    WRITE_OPCODE( pc, CR_MULTMATRIXD_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackWindowVisibleRegion( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint cRects, const GLint * pRects ){    GLint i, size, cnt;    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pc;    size = 16 + cRects * 4 * sizeof(GLint);    CR_GET_BUFFERED_POINTER( pc, size );    WRITE_DATA( 0, GLint, size );    WRITE_DATA( 4, GLenum, CR_WINDOWVISIBLEREGION_EXTEND_OPCODE );    WRITE_DATA( 8, GLint, window );    WRITE_DATA( 12, GLint, cRects );    cnt = 16;    for (i=0; i<cRects; ++i)    {        WRITE_DATA(cnt, GLint, (GLint) pRects[4*i+0]);        WRITE_DATA(cnt+4, GLint, (GLint) pRects[4*i+1]);        WRITE_DATA(cnt+8, GLint, (GLint) pRects[4*i+2]);        WRITE_DATA(cnt+12, GLint, (GLint) pRects[4*i+3]);        cnt += 16;    }    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRYcrPackAreProgramsResidentNV(GLsizei n, const GLuint * programs,                                                        GLboolean *residences, GLboolean *return_val,                                                        int *writeback){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    int packet_length;    (void) return_val; /* Caller must compute this from residences!!! */    packet_length = sizeof(int) +   /* packet length */        sizeof(GLenum) +                        /* extend opcode */        sizeof(n) +                                 /* num programs */        n * sizeof(*programs) +         /* programs */        8 + 8;    CR_GET_BUFFERED_POINTER(pc, packet_length);    WRITE_DATA(0, int, packet_length);    WRITE_DATA(4, GLenum, CR_AREPROGRAMSRESIDENTNV_EXTEND_OPCODE);    WRITE_DATA(8, GLsizei, n);    crMemcpy(data_ptr + 12, programs, n * sizeof(*programs));    WRITE_NETWORK_POINTER(12 + n * sizeof(*programs),   (void *) residences);    WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_CMDBLOCK_CHECK_FLUSH(pc);    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackPolygonStipple( const GLubyte *mask ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    int nodata = crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB);    int packet_length = sizeof(int);    if (nodata)        packet_length += sizeof(GLint);    else        packet_length += 32*32/8;    CR_GET_BUFFERED_POINTER(pc, packet_length );    WRITE_DATA_AI(int, nodata);    if (nodata)    {        WRITE_DATA_AI(GLint, (GLint)(uintptr_t)mask);    }    else    {       crMemcpy( data_ptr, mask, 32*32/8 );    }    WRITE_OPCODE( pc, CR_POLYGONSTIPPLE_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackCombinerParameterivNV( GLenum pname, const GLint *params ){    /* floats and ints are the same size, so the packing should be the same */    CR_GET_PACKER_CONTEXT(pc);    if (__handleCombinerParameterData( pname, (const GLfloat *) params, CR_COMBINERPARAMETERIVNV_EXTEND_OPCODE ))        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void crPackFree( void *packet ){	CR_GET_PACKER_CONTEXT(pc);    	if ( IS_BUFFERED( packet ) )    {        CR_UNLOCK_PACKER_CONTEXT(pc);		return;    }    CR_UNLOCK_PACKER_CONTEXT(pc);		/* the pointer passed in doesn't include the space for the single	 * opcode (4 bytes because of the alignment requirement) or the	 * length field or the header */	crFree( (unsigned char *) packet - 8 - sizeof(CRMessageOpcodes) );}

void PACK_APIENTRY crPackLightivSWAP (GLenum light, GLenum pname, const GLint *params){    /* floats and ints are the same size, so the packing should be the same */    CR_GET_PACKER_CONTEXT(pc);    if (__handleLightData( light, pname, (const GLfloat *) params ))        WRITE_OPCODE( pc, CR_LIGHTIV_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void crPackAppendBuffer( const CRPackBuffer *src ){	CR_GET_PACKER_CONTEXT(pc);	const int num_data = crPackNumData(src);	const int num_opcode = crPackNumOpcodes(src);	CRASSERT(num_data >= 0);	CRASSERT(num_opcode >= 0);    CR_LOCK_PACKER_CONTEXT(pc);	/* don't append onto ourself! */	CRASSERT(pc->currentBuffer);	CRASSERT(pc->currentBuffer != src);	if (!crPackCanHoldBuffer(src))	{		if (src->holds_BeginEnd)		{			crWarning( "crPackAppendBuffer: overflowed the destination!" );            CR_UNLOCK_PACKER_CONTEXT(pc);			return;		}		else        {			crError( "crPackAppendBuffer: overflowed the destination!" );            CR_UNLOCK_PACKER_CONTEXT(pc);        }	}	/* 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;    CR_UNLOCK_PACKER_CONTEXT(pc);}

voidcrPackAppendBoundedBuffer( const CRPackBuffer *src, const CRrecti *bounds ){	CR_GET_PACKER_CONTEXT(pc);	const GLbyte *payload = (const GLbyte *) src->opcode_current + 1;	const int num_opcodes = crPackNumOpcodes(src);	const int length = src->data_current - src->opcode_current - 1;	CRASSERT(pc);    CR_LOCK_PACKER_CONTEXT(pc);	CRASSERT(pc->currentBuffer);	CRASSERT(pc->currentBuffer != src);	/*	 * payload points to the block of opcodes immediately followed by operands.	 */	if ( !crPackCanHoldBoundedBuffer( src ) )	{		if (src->holds_BeginEnd)		{			crWarning( "crPackAppendBoundedBuffer: overflowed the destination!" );            CR_UNLOCK_PACKER_CONTEXT(pc);			return;		}		else        {			crError( "crPackAppendBoundedBuffer: overflowed the destination!" );            CR_UNLOCK_PACKER_CONTEXT(pc);        }	}	if (pc->swapping)		crPackBoundsInfoCRSWAP( bounds, payload, length, num_opcodes );	else		crPackBoundsInfoCR( bounds, payload, length, num_opcodes );	pc->buffer.holds_BeginEnd |= src->holds_BeginEnd;	pc->buffer.in_BeginEnd = src->in_BeginEnd;	pc->buffer.holds_List |= src->holds_List;    CR_UNLOCK_PACKER_CONTEXT(pc);}

int crPackCanHoldBuffer( const CRPackBuffer *src ){	const int num_data = crPackNumData(src);	const int num_opcode = crPackNumOpcodes(src);    int res;	CR_GET_PACKER_CONTEXT(pc);    CR_LOCK_PACKER_CONTEXT(pc);	res = crPackCanHoldOpcode( pc, num_opcode, num_data );    CR_UNLOCK_PACKER_CONTEXT(pc);    return res;}

void PACK_APIENTRY crPackEndListSWAP( void ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pc;    CR_GET_BUFFERED_POINTER( pc, 8 );    WRITE_DATA( 0, GLint, SWAP32(8) );    WRITE_DATA( 4, GLenum, SWAP32(CR_ENDLIST_EXTEND_OPCODE) );    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    pc->buffer.in_List = GL_FALSE;    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackEdgeFlagPointer( GLsizei stride, const GLvoid *pointer ){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	int packet_length = 16;	CR_GET_BUFFERED_POINTER( pc, packet_length );	WRITE_DATA( 0, GLint, packet_length );	WRITE_DATA( 4, GLenum, CR_EDGEFLAGPOINTER_EXTEND_OPCODE );	WRITE_DATA( 8, GLsizei, stride );	WRITE_DATA( 12, GLuint, (GLuint) ((uintptr_t) pointer) );	WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

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 PACK_APIENTRY crPackInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer ){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	int packet_length = 20;	CR_GET_BUFFERED_POINTER( pc, packet_length );	WRITE_DATA( 0, GLint, packet_length );	WRITE_DATA( 4, GLenum, CR_INTERLEAVEDARRAYS_EXTEND_OPCODE );	WRITE_DATA( 8, GLenum, format );	WRITE_DATA( 12, GLsizei, stride );	WRITE_DATA( 16, GLuint, (GLuint) ((uintptr_t) pointer) );	WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackFogCoordPointerEXT( GLenum type, GLsizei stride, const GLvoid * pointer ){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	int packet_length = 20;	CR_GET_BUFFERED_POINTER( pc, packet_length );	WRITE_DATA( 0, GLint, packet_length );	WRITE_DATA( 4, GLenum, CR_FOGCOORDPOINTEREXT_EXTEND_OPCODE );	WRITE_DATA( 8, GLenum, type );	WRITE_DATA( 12, GLsizei, stride );	WRITE_DATA( 16, GLuint, (GLuint) ((uintptr_t) pointer) );	WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

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 PACK_APIENTRY crPackVertexAttrib4ubvARB(GLuint index, const GLubyte * v){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    CR_GET_BUFFERED_POINTER(pc, 8);    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 4;    pc->current.attribsUsedMask |= (1 << index);    WRITE_DATA(0, GLuint, index);    WRITE_DATA(4, GLubyte, v[0]);    WRITE_DATA(5, GLubyte, v[1]);    WRITE_DATA(6, GLubyte, v[2]);    WRITE_DATA(7, GLubyte, v[3]);    WRITE_OPCODE(pc, CR_VERTEXATTRIB4UBVARB_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackNewListSWAP( GLuint list, GLenum mode ){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pc;    CR_GET_BUFFERED_POINTER( pc, 16 );    WRITE_DATA( 0, GLint, SWAP32(16) );    WRITE_DATA( 4, GLenum, SWAP32(CR_NEWLIST_EXTEND_OPCODE) );    WRITE_DATA( 8, GLuint, SWAP32(list) );    WRITE_DATA( 12, GLenum, SWAP32(mode) );    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    pc->buffer.in_List = GL_TRUE;    pc->buffer.holds_List = GL_TRUE;    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackGetUniformsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData, int * writeback){	CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pData;    CR_GET_BUFFERED_POINTER(pc, 32);    WRITE_DATA(0, GLint, 32);    WRITE_DATA(4, GLenum, CR_GETUNIFORMSLOCATIONS_EXTEND_OPCODE);    WRITE_DATA(8, GLuint, program);    WRITE_DATA(12, GLsizei, maxcbData);    WRITE_NETWORK_POINTER(16, (void *) cbData);    WRITE_NETWORK_POINTER(24, (void *) writeback);    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog, int * writeback){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	(void) pc;	CR_GET_BUFFERED_POINTER(pc, 32);	WRITE_DATA(0, GLint, 32);	WRITE_DATA(4, GLenum, CR_GETINFOLOGARB_EXTEND_OPCODE);	WRITE_DATA(8, GLhandleARB, obj);	WRITE_DATA(12, GLsizei, maxLength);	WRITE_NETWORK_POINTER(16, (void *) length);	WRITE_NETWORK_POINTER(24, (void *) writeback);	WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj, int * writeback){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	(void) pc;	CR_GET_BUFFERED_POINTER(pc, 32);	WRITE_DATA(0, GLint, 32);	WRITE_DATA(4, GLenum, CR_GETATTACHEDOBJECTSARB_EXTEND_OPCODE);	WRITE_DATA(8, GLhandleARB, containerObj);	WRITE_DATA(12, GLsizei, maxCount);	WRITE_NETWORK_POINTER(16, (void *) count);	WRITE_NETWORK_POINTER(24, (void *) writeback);	WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}

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 PACK_APIENTRY crPackSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ){	CR_GET_PACKER_CONTEXT(pc);	unsigned char *data_ptr;	int packet_length = 24;	CR_GET_BUFFERED_POINTER( pc, packet_length );	WRITE_DATA( 0, GLint, packet_length );	WRITE_DATA( 4, GLenum, CR_SECONDARYCOLORPOINTEREXT_EXTEND_OPCODE );	WRITE_DATA( 8, GLint, size );	WRITE_DATA( 12, GLenum, type );	WRITE_DATA( 16, GLsizei, stride );	WRITE_DATA( 20, GLuint, (GLuint) ((uintptr_t) pointer) );	WRITE_OPCODE( pc, CR_EXTEND_OPCODE );    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, char * source, int * writeback){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pc;    (void) source;    CR_GET_BUFFERED_POINTER(pc, 32);    WRITE_DATA(0, GLint, 32);    WRITE_DATA(4, GLenum, CR_GETSHADERSOURCE_EXTEND_OPCODE);    WRITE_DATA(8, GLuint, shader);    WRITE_DATA(12, GLsizei, bufSize);    WRITE_NETWORK_POINTER(16, (void *) length);    WRITE_NETWORK_POINTER(24, (void *) writeback);    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}

void PACK_APIENTRY crPackGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, char * infoLog, int * writeback){    CR_GET_PACKER_CONTEXT(pc);    unsigned char *data_ptr;    (void) pc;    (void) infoLog;    CR_GET_BUFFERED_POINTER(pc, 32);    WRITE_DATA(0, GLint, 32);    WRITE_DATA(4, GLenum, CR_GETPROGRAMINFOLOG_EXTEND_OPCODE);    WRITE_DATA(8, GLuint, program);    WRITE_DATA(12, GLsizei, bufSize);    WRITE_NETWORK_POINTER(16, (void *) length);    WRITE_NETWORK_POINTER(24, (void *) writeback);    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);    CR_UNLOCK_PACKER_CONTEXT(pc);}