diff options
Diffstat (limited to 'src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c')
| -rw-r--r-- | src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c | 981 |
1 files changed, 981 insertions, 0 deletions
diff --git a/src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c b/src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c new file mode 100644 index 00000000..4fd59ed6 --- /dev/null +++ b/src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c @@ -0,0 +1,981 @@ +/* Copyright (c) 2001, Stanford University + * All rights reserved + * + * See the file LICENSE.txt for information on redistributing this software. + */ + +#include "packer.h" +#include "cr_pixeldata.h" +#include "cr_error.h" +#include "cr_string.h" +#include "cr_version.h" + +void PACK_APIENTRY crPackTexImage1DSWAP(GLenum target, GLint level, + GLint internalformat, GLsizei width, 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( border ) + + sizeof( format ) + + sizeof( type ) + + sizeof( int ); + + if (pixels) + { + packet_length += 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(internalformat) ); + WRITE_DATA( 12, GLsizei, SWAP32(width) ); + WRITE_DATA( 16, GLint, SWAP32(border) ); + WRITE_DATA( 20, GLenum, SWAP32(format) ); + WRITE_DATA( 24, GLenum, SWAP32(type) ); + WRITE_DATA( 28, int, SWAP32(isnull) ); + + if (pixels) { + CRPixelPackState tmpUnpackState = *unpackstate; + /* flip application-requested swapBytes state */ + tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE; + + crPixelCopy1D( (void *)(data_ptr + 32), format, type, + pixels, format, type, width, &tmpUnpackState ); + } + + crHugePacket( CR_TEXIMAGE1D_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 ); +} + +#if defined( GL_EXT_texture3D ) +void PACK_APIENTRY crPackTexImage3DEXTSWAP(GLenum target, GLint level, + GLenum 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_TEXIMAGE3DEXT_OPCODE, data_ptr ); + crPackFree( data_ptr ); +} +#endif /* GL_EXT_texture3D */ + +#ifdef CR_OPENGL_VERSION_1_2 +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 ); +} +#endif /* CR_OPENGL_VERSION_1_2 */ + + +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 ); +} + +static void __handleTexEnvData( GLenum target, GLenum pname, const GLfloat *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + unsigned char *data_ptr; + int num_params; + int i; + + int packet_length = + sizeof( int ) + + sizeof( target ) + + sizeof( pname ); + + num_params = 1; + if ( pname == GL_TEXTURE_ENV_COLOR ) + { + num_params = 4; + } + + packet_length += num_params*sizeof(*params); + + CR_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] ) ); + } +} + + +void PACK_APIENTRY crPackTexEnvfvSWAP( GLenum target, GLenum pname, + const GLfloat *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + __handleTexEnvData( target, pname, params ); + WRITE_OPCODE( pc, CR_TEXENVFV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexEnvivSWAP( GLenum target, GLenum pname, + const GLint *params ) +{ + /* floats and ints are the same size, so the packing should be the same */ + CR_GET_PACKER_CONTEXT(pc); + __handleTexEnvData( target, pname, (const GLfloat *) params ); + WRITE_OPCODE( pc, CR_TEXENVIV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexEnviSWAP( GLenum target, GLenum pname, GLint param ) +{ + crPackTexEnvivSWAP( target, pname, ¶m ); +} + +void PACK_APIENTRY crPackTexEnvfSWAP( GLenum target, GLenum pname, GLfloat param ) +{ + crPackTexEnvfvSWAP( target, pname, ¶m ); +} + +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 ); +} + +static void __handleTexGenData( GLenum coord, GLenum pname, + int sizeof_param, const GLvoid *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + unsigned char *data_ptr; + int packet_length = sizeof( int ) + sizeof( coord ) + sizeof( pname ); + int num_params = 1; + int i; + if (pname == GL_OBJECT_PLANE || pname == GL_EYE_PLANE) + { + num_params = 4; + } + packet_length += num_params * sizeof_param; + + CR_GET_BUFFERED_POINTER(pc, packet_length ); + WRITE_DATA( 0, int, SWAP32(packet_length) ); + WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(coord) ); + WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) ); + for ( i = 0 ; i < num_params ; i++) + { + WRITE_DATA( (i+1)*sizeof( int ) + 8, GLint, SWAP32(((GLint *)params)[i]) ); + } +} + +void PACK_APIENTRY crPackTexGendvSWAP( GLenum coord, GLenum pname, + const GLdouble *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + __handleTexGenData( coord, pname, sizeof( *params ), params ); + WRITE_OPCODE( pc, CR_TEXGENDV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexGenfvSWAP( GLenum coord, GLenum pname, + const GLfloat *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + __handleTexGenData( coord, pname, sizeof( *params ), params ); + WRITE_OPCODE( pc, CR_TEXGENFV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexGenivSWAP( GLenum coord, GLenum pname, + const GLint *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + __handleTexGenData( coord, pname, sizeof( *params ), params ); + WRITE_OPCODE( pc, CR_TEXGENIV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexGendSWAP( GLenum coord, GLenum pname, GLdouble param ) +{ + crPackTexGendvSWAP( coord, pname, ¶m ); +} + +void PACK_APIENTRY crPackTexGenfSWAP( GLenum coord, GLenum pname, GLfloat param ) +{ + crPackTexGenfvSWAP( coord, pname, ¶m ); +} + +void PACK_APIENTRY crPackTexGeniSWAP( GLenum coord, GLenum pname, GLint param ) +{ + crPackTexGenivSWAP( coord, pname, ¶m ); +} + +static GLboolean __handleTexParameterData( GLenum target, GLenum pname, const GLfloat *params ) +{ + CR_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); + + CR_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; +} + +void PACK_APIENTRY crPackTexParameterfvSWAP( GLenum target, GLenum pname, + const GLfloat *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + if (__handleTexParameterData( target, pname, params )) + WRITE_OPCODE( pc, CR_TEXPARAMETERFV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexParameterivSWAP( GLenum target, GLenum pname, + const GLint *params ) +{ + CR_GET_PACKER_CONTEXT(pc); + if (__handleTexParameterData( target, pname, (GLfloat *) params )) + WRITE_OPCODE( pc, CR_TEXPARAMETERIV_OPCODE ); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + +void PACK_APIENTRY crPackTexParameterfSWAP( GLenum target, GLenum pname, GLfloat param ) +{ + crPackTexParameterfvSWAP( target, pname, ¶m ); +} + +void PACK_APIENTRY crPackTexParameteriSWAP( GLenum target, GLenum pname, GLint param ) +{ + crPackTexParameterivSWAP( target, pname, ¶m ); +} + +#ifdef CR_OPENGL_VERSION_1_2 +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 ); +} +#endif /* CR_OPENGL_VERSION_1_2 */ + +void PACK_APIENTRY crPackTexSubImage2DSWAP (GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, + 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( yoffset ) + + sizeof( width ) + + sizeof( height ) + + sizeof( format ) + + sizeof( type ) + + 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(xoffset) ); + WRITE_DATA( 12, GLint, SWAP32(yoffset) ); + WRITE_DATA( 16, GLsizei, SWAP32(width) ); + WRITE_DATA( 20, GLsizei, SWAP32(height) ); + WRITE_DATA( 24, GLenum, SWAP32(format) ); + WRITE_DATA( 28, GLenum, SWAP32(type) ); + + /* flip application-requested swapBytes state */ + tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE; + + crPixelCopy2D( width, height, + (GLvoid *) (data_ptr + 32), format, type, NULL, /* dst */ + pixels, format, type, &tmpUnpackState ); /* src */ + + crHugePacket( CR_TEXSUBIMAGE2D_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 crPackAreTexturesResidentSWAP( GLsizei n, const GLuint *textures, GLboolean *residences, GLboolean *return_val, int *writeback ) +{ + CR_GET_PACKER_CONTEXT(pc); + unsigned char *data_ptr; + int packet_length; + int i; + + packet_length = + sizeof( int ) + /* packet length */ + sizeof( GLenum ) + /* extend-o opcode */ + sizeof( n ) + /* num_textures */ + n*sizeof( *textures ) + /* textures */ + 8 + 8 + 8; /* return pointers */ + + CR_GET_BUFFERED_POINTER(pc, packet_length); + WRITE_DATA( 0, int, SWAP32(packet_length) ); + WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(CR_ARETEXTURESRESIDENT_EXTEND_OPCODE) ); + WRITE_DATA( sizeof( int ) + 4, GLsizei, SWAP32(n) ); + for (i = 0 ; i < n ; i++) + { + WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAP32(textures[i]) ); + } + WRITE_NETWORK_POINTER( sizeof( int ) + 8 + n*sizeof( *textures ), (void *) residences ); + WRITE_NETWORK_POINTER( sizeof( int ) + 16 + n*sizeof( *textures ), (void *) return_val ); + WRITE_NETWORK_POINTER( sizeof( int ) + 24 + n*sizeof( *textures ), (void *) writeback ); + WRITE_OPCODE( pc, CR_EXTEND_OPCODE ); + CR_CMDBLOCK_CHECK_FLUSH(pc); + CR_UNLOCK_PACKER_CONTEXT(pc); +} + + +/********************************************************************** + * Texture compression + */ + +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 crPackCompressedTexImage2DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, 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( height ) + + sizeof( border ) + + sizeof( imagesize ) + + sizeof( int ); /* isnull */ + + if (data) + { + packet_length += imagesize; + } + + data_ptr = (unsigned char *) crPackAlloc( packet_length ); + WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE2DARB_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, GLsizei, SWAP32(height) ); + WRITE_DATA( 24, GLint, SWAP32(border) ); + WRITE_DATA( 28, GLsizei, SWAP32(imagesize) ); + WRITE_DATA( 32, int, SWAP32(isnull) ); + + if (data) { + crMemcpy( (void *)(data_ptr + 36), (void *)data, imagesize); + } + + crHugePacket( CR_EXTEND_OPCODE, data_ptr ); + crPackFree( data_ptr ); +} + +void PACK_APIENTRY crPackCompressedTexImage3DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, 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( height ) + + sizeof( depth ) + + sizeof( border ) + + sizeof( imagesize ) + + sizeof( int ); /* isnull */ + + if (data) + { + packet_length += imagesize; + } + + data_ptr = (unsigned char *) crPackAlloc( packet_length ); + WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE3DARB_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, GLsizei, SWAP32(height) ); + WRITE_DATA( 24, GLsizei, SWAP32(depth) ); + WRITE_DATA( 28, GLint, SWAP32(border) ); + WRITE_DATA( 32, GLsizei, SWAP32(imagesize) ); + WRITE_DATA( 36, int, SWAP32(isnull) ); + + if (data) { + crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize); + } + + crHugePacket( CR_EXTEND_OPCODE, data_ptr ); + crPackFree( data_ptr ); +} + +void PACK_APIENTRY crPackCompressedTexSubImage1DARBSWAP( GLenum target, GLint level, GLint xoffset, GLsizei width, 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( width ) + + 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_COMPRESSEDTEXSUBIMAGE1DARB_EXTEND_OPCODE) ); + WRITE_DATA( 4, GLenum, SWAP32(target) ); + WRITE_DATA( 8, GLint, SWAP32(level) ); + WRITE_DATA( 12, GLint, SWAP32(xoffset) ); + WRITE_DATA( 16, GLsizei, SWAP32(width) ); + WRITE_DATA( 20, GLenum, SWAP32(format) ); + 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 crPackCompressedTexSubImage2DARBSWAP( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, 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( width ) + + sizeof( height ) + + 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_COMPRESSEDTEXSUBIMAGE2DARB_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, GLsizei, SWAP32(width) ); + WRITE_DATA( 24, GLsizei, SWAP32(height) ); + WRITE_DATA( 28, GLenum, SWAP32(format) ); + WRITE_DATA( 32, GLsizei, SWAP32(imagesize) ); + WRITE_DATA( 36, int, SWAP32(isnull) ); + + if (data) { + crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize); + } + + crHugePacket( CR_EXTEND_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 crPackGetCompressedTexImageARBSWAP( GLenum target, GLint level, GLvoid *img, int *writeback ) +{ + CR_GET_PACKER_CONTEXT(pc); + crError ( "GetCompressedTexImageARB needs to be special cased!"); + (void) pc; + (void) target; + (void) level; + (void) img; + (void) writeback; +} |