void PACK_APIENTRY crPackAreProgramsResidentNV(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 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 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 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); }
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 crPackShaderSource(GLuint shader, GLsizei count, const char **string, const GLint *length) { CR_GET_PACKER_CONTEXT(pc); unsigned char *data_ptr; GLint *pLocalLength; int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(shader)+sizeof(count)+sizeof(GLint)+count*sizeof(*pLocalLength); GLsizei i; if ((0==count) || (!string)) return; pLocalLength = crAlloc(count*sizeof(*length)); if (!pLocalLength) return; for (i=0; i<count; ++i) { pLocalLength[i] = (length && (length[i]>=0)) ? length[i] : crStrlen(string[i])+1; packet_length += pLocalLength[i]; } if (length) { packet_length += count*sizeof(*length); } CR_GET_BUFFERED_POINTER(pc, packet_length); WRITE_DATA_AI(int, packet_length); WRITE_DATA_AI(GLenum, CR_SHADERSOURCE_EXTEND_OPCODE); WRITE_DATA_AI(GLuint, shader); WRITE_DATA_AI(GLsizei, count); WRITE_DATA_AI(GLint, (GLint)(length ? 1:0)); crMemcpy(data_ptr, pLocalLength, count*sizeof(*pLocalLength)); data_ptr += count*sizeof(*pLocalLength); if (length) { crMemcpy(data_ptr, length, count*sizeof(*length)); data_ptr += count*sizeof(*length); } for (i=0; i<count; ++i) { if (string[i]) { crMemcpy(data_ptr, string[i], pLocalLength[i]); } else { CRASSERT(pLocalLength[i]==1); *data_ptr = 0; } data_ptr += pLocalLength[i]; } WRITE_OPCODE(pc, CR_EXTEND_OPCODE); CR_UNLOCK_PACKER_CONTEXT(pc); crFree(pLocalLength); }
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 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 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 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 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 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 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 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 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); }
void PACK_APIENTRY crPackGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders, int * writeback) { CR_GET_PACKER_CONTEXT(pc); unsigned char *data_ptr; (void) pc; (void) shaders; CR_GET_BUFFERED_POINTER(pc, 32); WRITE_DATA(0, GLint, 32); WRITE_DATA(4, GLenum, CR_GETATTACHEDSHADERS_EXTEND_OPCODE); WRITE_DATA(8, GLuint, program); 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 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); }
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 crPackVertexAttribPointerNV( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) { CR_GET_PACKER_CONTEXT(pc); unsigned char *data_ptr; int packet_length = 28; CR_GET_BUFFERED_POINTER( pc, packet_length ); WRITE_DATA( 0, GLint, packet_length ); WRITE_DATA( 4, GLenum, CR_VERTEXATTRIBPOINTERNV_EXTEND_OPCODE ); WRITE_DATA( 8, GLint, index ); WRITE_DATA( 12, GLint, size ); WRITE_DATA( 16, GLenum, type ); WRITE_DATA( 20, GLsizei, stride ); WRITE_DATA( 24, GLuint, (GLuint) ((uintptr_t) pointer) ); WRITE_OPCODE( pc, CR_EXTEND_OPCODE ); CR_UNLOCK_PACKER_CONTEXT(pc); }