void PACK_APIENTRY crPackBufferDataARBSWAP( GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage ) { unsigned char *data_ptr, *start_ptr; int packet_length; packet_length = sizeof(GLenum) + sizeof(target) + sizeof(GLuint) + sizeof(usage) + sizeof(GLint); /*Note: it's valid to pass a NULL pointer here, which tells GPU drivers to allocate memory for the VBO*/ if (data) packet_length += size; start_ptr = data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA_AI(GLenum, SWAP32(CR_BUFFERDATAARB_EXTEND_OPCODE) ); WRITE_DATA_AI(GLenum, SWAP32(target) ); WRITE_DATA_AI(GLuint, SWAP32((GLuint) size) ); WRITE_DATA_AI(GLenum, SWAP32(usage) ); WRITE_DATA_AI(GLint, SWAP32((GLint) (data!=NULL)) ); if (data) crMemcpy(data_ptr, data, size); crHugePacket( CR_EXTEND_OPCODE, start_ptr ); crPackFree( start_ptr ); }
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); }
void PACK_APIENTRY crPackTexSubImage1DSWAP (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate ) { unsigned char *data_ptr; int packet_length; CRPixelPackState tmpUnpackState = *unpackstate; packet_length = sizeof( target ) + sizeof( level ) + sizeof( xoffset ) + sizeof( width ) + sizeof( format ) + sizeof( type ) + crImageSize( format, type, width, 1 ); data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32(target) ); WRITE_DATA( 4, GLint, SWAP32(level) ); WRITE_DATA( 8, GLint, SWAP32(xoffset) ); WRITE_DATA( 12, GLsizei, SWAP32(width) ); WRITE_DATA( 16, GLenum, SWAP32(format) ); WRITE_DATA( 20, GLenum, SWAP32(type) ); /* flip application-requested swapBytes state */ tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE; crPixelCopy1D((GLvoid *) (data_ptr + 24), format, type, pixels, format, type, width, &tmpUnpackState ); crHugePacket( CR_TEXSUBIMAGE1D_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackLockArraysEXT(GLint first, GLint count) { CRContext *g = crStateGetCurrent(); CRClientState *c = &g->client; unsigned char *data_ptr, *start_ptr; int packet_length = sizeof(int); /*extopcode*/ int vertex_size, i, numenabled; packet_length += sizeof(first) + sizeof(count); /*params*/ numenabled = crPack_GetNumEnabledArrays(c, &vertex_size); packet_length += sizeof(int) + numenabled*sizeof(int); /*numenabled + indices*/ packet_length += vertex_size * count; /*vertices data*/ start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length); WRITE_DATA_AI(GLenum, CR_LOCKARRAYSEXT_EXTEND_OPCODE ); WRITE_DATA_AI(GLint, first); WRITE_DATA_AI(GLint, count); WRITE_DATA_AI(int, numenabled); for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i) { crPackLockClientPointer(first, count, &data_ptr, i, c); } crHugePacket(CR_EXTEND_OPCODE, start_ptr); crPackFree(start_ptr); }
void PACK_APIENTRY crPackPrioritizeTexturesSWAP( GLsizei n, const GLuint *textures, const GLclampf *priorities ) { unsigned char *data_ptr; int packet_length = sizeof( n ) + n*sizeof( *textures ) + n*sizeof( *priorities ); int i; data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLsizei, SWAP32(n) ); for ( i = 0 ; i < n ; i++) { WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i])); } for ( i = 0 ; i < n ; i++) { WRITE_DATA( i*sizeof(int) + 4 + n*sizeof( *textures ), GLuint, SWAPFLOAT(priorities[i])); } crHugePacket( CR_PRIORITIZETEXTURES_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackPixelMapusvSWAP(GLenum map, GLsizei mapsize, const GLushort *values ) { unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values ); crHugePacket( CR_PIXELMAPUSV_OPCODE, data_ptr ); crPackFree( data_ptr ); }
/* * Put the given buffer list into the free buffer pool. We do this when * we've finished rendering a frame and no longer need the buffer list. */ void hiddenlineReclaimPackBuffer( BufList *bl ) { if (bl->can_reclaim) { GET_CONTEXT(context); crBufferPoolPush( context->bufpool, bl->buf, hiddenline_spu.buffer_size ); } else { crPackFree( bl->buf ); } }
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 crPackTexImage2DSWAP(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate ) { unsigned char *data_ptr; int packet_length; int isnull = (pixels == NULL); packet_length = sizeof( target ) + sizeof( level ) + sizeof( internalformat ) + sizeof( width ) + sizeof( height ) + sizeof( border ) + sizeof( format ) + sizeof( type ) + sizeof( int ); if (pixels) { packet_length += crImageSize( format, type, width, height ); } data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32(target) ); WRITE_DATA( 4, GLint, SWAP32(level) ); WRITE_DATA( 8, GLint, SWAP32(internalformat) ); WRITE_DATA( 12, GLsizei, SWAP32(width) ); WRITE_DATA( 16, GLsizei, SWAP32(height) ); WRITE_DATA( 20, GLint, SWAP32(border) ); WRITE_DATA( 24, GLenum, SWAP32(format) ); WRITE_DATA( 28, GLenum, SWAP32(type) ); WRITE_DATA( 32, int, SWAP32(isnull) ); if (pixels) { CRPixelPackState tmpUnpackState = *unpackstate; /* flip application-requested swapBytes state */ tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE; crPixelCopy2D( width, height, (void *)(data_ptr + 36), format, type, NULL, /* dst */ pixels, format, type, &tmpUnpackState ); /* src */ } crHugePacket( CR_TEXIMAGE2D_OPCODE, data_ptr ); crPackFree( data_ptr ); }
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 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 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 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); }
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 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); }
/* 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 ); }
void PACK_APIENTRY crPackDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate ) { unsigned char *data_ptr; int packet_length, imagesize; int noimagedata = (pixels == NULL) || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB); packet_length = sizeof( width ) + sizeof( height ) + sizeof( format ) + sizeof( type ) + sizeof(int) + sizeof(GLint); if (!noimagedata) { imagesize = crImageSize( format, type, width, height ); if (imagesize<=0) { crDebug("crPackDrawPixels: 0 image size, ignoring"); return; } packet_length += imagesize; } data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLsizei, width ); WRITE_DATA( 4, GLsizei, height ); WRITE_DATA( 8, GLenum, format ); WRITE_DATA( 12, GLenum, type ); WRITE_DATA( 16, GLint, noimagedata ); WRITE_DATA( 20, GLint, (GLint) (uintptr_t) pixels ); if (!noimagedata) { crPixelCopy2D(width, height, (void *) (data_ptr + 24), format, type, NULL, /* dst */ pixels, format, type, unpackstate); /* src */ } crHugePacket( CR_DRAWPIXELS_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackDeleteTexturesSWAP( GLsizei n, const GLuint *textures ) { unsigned char *data_ptr; int i; int packet_length = sizeof( n ) + n*sizeof( *textures ); data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLsizei, SWAP32(n) ); for ( i = 0 ; i < n ; i++) { WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]) ); } crHugePacket( CR_DELETETEXTURES_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackCompressedTexImage1DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, 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( internalformat ) + sizeof( width ) + sizeof( border ) + sizeof( imagesize ) + sizeof( int ); if (data) { packet_length += imagesize; } data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE1DARB_EXTEND_OPCODE) ); WRITE_DATA( 4, GLenum, SWAP32(target) ); WRITE_DATA( 8, GLint, SWAP32(level) ); WRITE_DATA( 12, GLint, SWAP32(internalformat) ); WRITE_DATA( 16, GLsizei, SWAP32(width) ); WRITE_DATA( 20, GLint, SWAP32(border) ); WRITE_DATA( 24, GLsizei, SWAP32(imagesize) ); WRITE_DATA( 28, int, SWAP32(isnull) ); if (data) { crMemcpy( (void *)(data_ptr + 32), (void *)data, imagesize); } crHugePacket( CR_EXTEND_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackTexSubImage3DSWAP (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate ) { unsigned char *data_ptr; int packet_length; packet_length = sizeof( target ) + sizeof( level ) + sizeof( xoffset ) + sizeof( yoffset ) + sizeof( zoffset ) + sizeof( width ) + sizeof( height ) + sizeof( depth ) + sizeof( format ) + sizeof( type ) + crTextureSize( format, type, width, height, depth ); data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32(target) ); WRITE_DATA( 4, GLint, SWAP32(level) ); WRITE_DATA( 8, GLint, SWAP32(xoffset) ); WRITE_DATA( 12, GLint, SWAP32(yoffset) ); WRITE_DATA( 16, GLint, SWAP32(zoffset) ); WRITE_DATA( 20, GLsizei, SWAP32(width) ); WRITE_DATA( 24, GLsizei, SWAP32(height) ); WRITE_DATA( 28, GLsizei, SWAP32(depth) ); WRITE_DATA( 32, GLenum, SWAP32(format) ); WRITE_DATA( 36, GLenum, SWAP32(type) ); crPixelCopy3D( width, height, depth, (GLvoid *) (data_ptr + 36), format, type, NULL, /* dst */ pixels, format, type, unpackstate ); /* src */ crHugePacket( CR_TEXSUBIMAGE3D_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap, const CRPixelPackState *unpack ) { const int noimagedata = (bitmap == NULL) || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB); unsigned char *data_ptr; int data_length = 0; GLubyte *destBitmap = NULL; int packet_length = sizeof( width ) + sizeof( height ) + sizeof( xorig ) + sizeof( yorig ) + sizeof( xmove ) + sizeof( ymove ) + sizeof( GLuint ) + sizeof(GLint); if (!noimagedata) { data_length = CEIL8(width) * height / 8; packet_length += data_length; } data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLsizei, width ); WRITE_DATA( 4, GLsizei, height ); WRITE_DATA( 8, GLfloat, xorig ); WRITE_DATA( 12, GLfloat, yorig ); WRITE_DATA( 16, GLfloat, xmove ); WRITE_DATA( 20, GLfloat, ymove ); WRITE_DATA( 24, GLuint, noimagedata ); WRITE_DATA( 28, GLint, (GLint) (uintptr_t) bitmap); if (!noimagedata) crBitmapCopy(width, height, (GLubyte *)(data_ptr + 32), bitmap, unpack); crHugePacket( CR_BITMAP_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackBufferDataARBSWAP( GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage ) { unsigned char *data_ptr; int packet_length; packet_length = sizeof(GLenum) + sizeof(target) + sizeof(size) + sizeof(usage) + size; data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32(CR_BUFFERDATAARB_EXTEND_OPCODE) ); WRITE_DATA( 4, GLenum, SWAP32(target) ); WRITE_DATA( 8, GLsizeiptrARB, SWAP32(size) ); WRITE_DATA( 12, GLenum, SWAP32(usage) ); if (data) crMemcpy( data_ptr + 16, data, size ); crHugePacket( CR_EXTEND_OPCODE, data_ptr ); crPackFree( data_ptr ); }
void PACK_APIENTRY crPackBufferSubDataARBSWAP( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data ) { unsigned char *data_ptr, *start_ptr; int packet_length; if (!data) return; packet_length = sizeof(GLenum) + sizeof(target) + sizeof(GLuint) + sizeof(GLuint) + size; start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length); WRITE_DATA_AI(GLenum, SWAP32(CR_BUFFERSUBDATAARB_EXTEND_OPCODE) ); WRITE_DATA_AI(GLenum, SWAP32(target) ); WRITE_DATA_AI(GLuint, SWAP32((GLuint) offset) ); WRITE_DATA_AI(GLuint, SWAP32((GLuint) size) ); crMemcpy(data_ptr, data, size); crHugePacket(CR_EXTEND_OPCODE, start_ptr); crPackFree(start_ptr); }
void PACK_APIENTRY crPackTexImage3DSWAP(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate ) { unsigned char *data_ptr; int packet_length; int isnull = (pixels == NULL); int is_distrib = ( (type == GL_TRUE) || (type == GL_FALSE) ) ; int distrib_buf_len = 0; int tex_size = 0; packet_length = sizeof( target ) + sizeof( level ) + sizeof( internalformat ) + sizeof( width ) + sizeof( height ) + sizeof( depth ) + sizeof( border ) + sizeof( format ) + sizeof( type ) + sizeof( int ); if (pixels) { if ( is_distrib ) { distrib_buf_len = crStrlen( pixels ) + 1 + ( (type == GL_TRUE) ? width*height*3 : 0 ) ; packet_length += distrib_buf_len ; } else { tex_size = crTextureSize( format, type, width, height, depth ); packet_length += tex_size; } } data_ptr = (unsigned char *) crPackAlloc( packet_length ); WRITE_DATA( 0, GLenum, SWAP32( target ) ); WRITE_DATA( 4, GLint, SWAP32( level ) ); WRITE_DATA( 8, GLint, SWAP32( internalformat ) ); WRITE_DATA( 12, GLsizei, SWAP32( width ) ); WRITE_DATA( 16, GLsizei, SWAP32( height ) ); WRITE_DATA( 20, GLsizei, SWAP32( depth ) ); WRITE_DATA( 24, GLint, SWAP32( border ) ); WRITE_DATA( 28, GLenum, SWAP32( format ) ); WRITE_DATA( 32, GLenum, SWAP32( type ) ); WRITE_DATA( 36, int, SWAP32( isnull ) ); if (pixels) { if ( is_distrib ) { crMemcpy( (void*)(data_ptr + 40), pixels, distrib_buf_len ) ; } else { CRPixelPackState tmpUnpackState = *unpackstate; /* flip application-requested swapBytes state */ tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE; crPixelCopy3D( width, height, depth, (void *)(data_ptr + 40), format, type, NULL, pixels, format, type, &tmpUnpackState ); } } crHugePacket( CR_TEXIMAGE3D_OPCODE, data_ptr ); crPackFree( data_ptr ); }