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; }