void PACK_APIENTRY crPackCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat *params )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
CR_GET_BUFFERED_POINTER(pc, 32 );
WRITE_DATA( 0, GLint, 32 );
WRITE_DATA( 4, GLenum, CR_COMBINERSTAGEPARAMETERFVNV_EXTEND_OPCODE );
WRITE_DATA( 8, GLenum, stage );
WRITE_DATA( 12, GLenum, pname );
WRITE_DATA( 16, GLfloat, params[0] );
WRITE_DATA( 20, GLfloat, params[1] );
WRITE_DATA( 24, GLfloat, params[2] );
WRITE_DATA( 28, GLfloat, params[3] );
WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params, int *writeback)
{
int packet_length = 32 + len;
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, GLint, packet_length);
WRITE_DATA(4, GLenum, CR_GETPROGRAMNAMEDPARAMETERDVNV_EXTEND_OPCODE);
WRITE_DATA(8, GLuint, id);
WRITE_DATA(12, GLsizei, len);
crMemcpy(data_ptr + 16, name, len);
WRITE_NETWORK_POINTER(16 + len, (void *) params);
WRITE_NETWORK_POINTER(16 + len + 8, (void *) writeback);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_CMDBLOCK_CHECK_FLUSH(pc);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = 32;
CR_GET_BUFFERED_POINTER( pc, packet_length );
WRITE_DATA( 0, GLint, packet_length );
WRITE_DATA( 4, GLenum, CR_VERTEXATTRIBPOINTERARB_EXTEND_OPCODE );
WRITE_DATA( 8, GLint, index );
WRITE_DATA( 12, GLint, size );
WRITE_DATA( 16, GLenum, type );
WRITE_DATA( 20, GLboolean, normalized );
WRITE_DATA( 24, GLsizei, stride );
WRITE_DATA( 28, GLuint, (GLuint) ((uintptr_t) pointer) );
WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackUniformMatrix4x3fv(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)
+ 4*3*count*sizeof(*value);
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_UNIFORMMATRIX4X3FV_EXTEND_OPCODE);
WRITE_DATA_AI(GLint, location);
WRITE_DATA_AI(GLsizei, count);
WRITE_DATA_AI(GLboolean, transpose);
crMemcpy(data_ptr, value, 4*3*count*sizeof(*value));
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY
crPackGetBufferSubDataARBSWAP( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data, int * writeback )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
(void) pc;
CR_GET_BUFFERED_POINTER( pc, 36 );
WRITE_DATA( 0, GLint, SWAP32(36) );
WRITE_DATA( 4, GLenum, SWAP32(CR_GETBUFFERSUBDATAARB_EXTEND_OPCODE) );
WRITE_DATA( 8, GLenum, SWAP32(target) );
WRITE_DATA( 12, GLuint, SWAP32((GLuint) offset) );
WRITE_DATA( 16, GLuint, SWAP32((GLuint) size) );
WRITE_NETWORK_POINTER( 20, (void *) data );
WRITE_NETWORK_POINTER( 28, (void *) writeback );
WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
CR_CMDBLOCK_CHECK_FLUSH(pc);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
{
/* Packing this command is only useful if we have server-side vertex
* arrays - GL_ARB_vertex_buffer_object. Note that pointer will really
* be an offset into a server-side buffer.
*/
GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = 20 + sizeof(GLintptrARB);
GET_BUFFERED_POINTER( pc, packet_length );
WRITE_DATA( 0, GLint, packet_length );
WRITE_DATA( 4, GLenum, CR_VERTEXPOINTER_EXTEND_OPCODE );
WRITE_DATA( 8, GLint, size );
WRITE_DATA( 12, GLenum, type );
WRITE_DATA( 16, GLsizei, stride );
WRITE_DATA( 20, GLintptrARB, (GLintptrARB) pointer );
WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
}
void PACK_APIENTRY crPackExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
{
const int packet_length = 32;
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_EXECUTEPROGRAMNV_EXTEND_OPCODE);
WRITE_DATA(8, GLenum, target);
WRITE_DATA(12, GLuint, id);
WRITE_DATA(16, GLfloat, params[0]);
WRITE_DATA(20, GLfloat, params[1]);
WRITE_DATA(24, GLfloat, params[2]);
WRITE_DATA(28, GLfloat, params[3]);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackGetUniformLocation(GLuint program, const char * name, GLint * return_value, int * writeback)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int cbName = crStrlen(name)+1;
int packet_length = sizeof(int)+sizeof(GLenum)+sizeof(program)+cbName*sizeof(*name)+16;
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA_AI(int, packet_length);
WRITE_DATA_AI(GLenum, CR_GETUNIFORMLOCATION_EXTEND_OPCODE);
WRITE_DATA_AI(GLuint, program);
crMemcpy(data_ptr, name, cbName*sizeof(*name));
data_ptr += cbName*sizeof(*name);
WRITE_NETWORK_POINTER(0, (void *) return_value);
WRITE_NETWORK_POINTER(8, (void *) writeback);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = 32 + len;
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, GLint, packet_length);
WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4FNV_EXTEND_OPCODE);
WRITE_DATA(8, GLuint, id);
WRITE_DATA(12, GLsizei, len);
WRITE_DATA(16, GLfloat, x);
WRITE_DATA(20, GLfloat, y);
WRITE_DATA(24, GLfloat, z);
WRITE_DATA(28, GLfloat, w);
crMemcpy((void *) (data_ptr + 32), name, len);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackBegin( GLenum mode )
{
GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
(void) pc;
if (pc->buffer.canBarf)
{
if (!pc->buffer.holds_BeginEnd)
pc->Flush( pc->flush_arg );
pc->buffer.in_BeginEnd = 1;
pc->buffer.holds_BeginEnd = 1;
}
GET_BUFFERED_POINTER( pc, 4 );
pc->current.begin_data = data_ptr;
pc->current.begin_op = pc->buffer.opcode_current;
pc->current.attribsUsedMask = 0;
WRITE_DATA( 0, GLenum, mode );
WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
}
void PACK_APIENTRY crPackGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, char * name, int * writeback)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
(void) pc;
(void) size;
(void) type;
(void) name;
CR_GET_BUFFERED_POINTER(pc, 36);
WRITE_DATA(0, GLint, 36);
WRITE_DATA(4, GLenum, CR_GETACTIVEUNIFORM_EXTEND_OPCODE);
WRITE_DATA(8, GLuint, program);
WRITE_DATA(12, GLuint, index);
WRITE_DATA(16, GLsizei, bufSize);
WRITE_NETWORK_POINTER(20, (void *) length);
WRITE_NETWORK_POINTER(28, (void *) writeback);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
int packet_length = 48 + len;
CR_GET_BUFFERED_POINTER(pc, packet_length);
WRITE_DATA(0, GLint, packet_length);
WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4DNV_EXTEND_OPCODE);
WRITE_DATA(8, GLenum, id);
WRITE_DATA(12, GLuint, len);
WRITE_DOUBLE(16, x);
WRITE_DOUBLE(24, y);
WRITE_DOUBLE(32, z);
WRITE_DOUBLE(40, w);
crMemcpy((void *) (data_ptr + 48), name, len);
WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
{
/* Packing this command is only useful if we have server-side vertex
* arrays - GL_ARB_vertex_buffer_object. Note that pointer will really
* be an offset into a server-side buffer.
* @todo Because of that we'd only transfer lowest 32bit as there're no 4gb+VBOs (yet?).
* Look at glgets regarding max vertices in arrays.
*/
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_VERTEXPOINTER_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
crPackGetTexImage( GLenum target, GLint level, GLenum format, GLenum type,
GLvoid * pixels, const CRPixelPackState * packstate,
int * writeback )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
(void) pc;
CR_GET_BUFFERED_POINTER( pc, 40 );
WRITE_DATA( 0, GLint, 40 );
WRITE_DATA( 4, GLenum, CR_GETTEXIMAGE_EXTEND_OPCODE );
WRITE_DATA( 8, GLenum, target );
WRITE_DATA( 12, GLint, level );
WRITE_DATA( 16, GLenum, format );
WRITE_DATA( 20, GLenum, type );
WRITE_NETWORK_POINTER( 24, (void *) pixels );
WRITE_NETWORK_POINTER( 32, (void *) writeback );
WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
CR_CMDBLOCK_CHECK_FLUSH(pc);
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackBoundsInfoCR( const CRrecti *bounds, const GLbyte *payload, GLint len, GLint num_opcodes )
{
CR_GET_PACKER_CONTEXT(pc);
/* Don't get the buffered_ptr here because we've already
* verified that there's enough space for everything. */
unsigned char *data_ptr;
int len_aligned, total_len;
CR_LOCK_PACKER_CONTEXT(pc);
data_ptr = pc->buffer.data_current;
len_aligned = ( len + 0x3 ) & ~0x3;
total_len = 24 + len_aligned;
WRITE_DATA( 0, int, total_len );
WRITE_DATA( 4, int, bounds->x1 );
WRITE_DATA( 8, int, bounds->y1 );
WRITE_DATA( 12, int, bounds->x2 );
WRITE_DATA( 16, int, bounds->y2 );
WRITE_DATA( 20, int, num_opcodes );
/* skip the BOUNDSINFO */
data_ptr += 24;
/* put in padding opcodes (deliberately bogus) */
switch ( len_aligned - len )
{
case 3: *data_ptr++ = 0xff; /* FALLTHROUGH */
case 2: *data_ptr++ = 0xff; /* FALLTHROUGH */
case 1: *data_ptr++ = 0xff; /* FALLTHROUGH */
default: break;
}
crMemcpy( data_ptr, payload, len );
WRITE_OPCODE( pc, CR_BOUNDSINFOCR_OPCODE );
pc->buffer.data_current += 24 + len_aligned;
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackBeginSWAP( GLenum mode )
{
CR_GET_PACKER_CONTEXT(pc);
unsigned char *data_ptr;
(void) pc;
if (pc->buffer.canBarf)
{
if (!pc->buffer.holds_BeginEnd)
pc->Flush( pc->flush_arg );
pc->buffer.in_BeginEnd = 1;
pc->buffer.holds_BeginEnd = 1;
}
CR_GET_BUFFERED_POINTER( pc, 4 );
CRASSERT(pc->enmBeginEndState == CRPackBeginEndStateNone);
pc->enmBeginEndState = CRPackBeginEndStateStarted;
pc->current.begin_data = data_ptr;
pc->current.begin_op = pc->buffer.opcode_current;
pc->current.attribsUsedMask = 0;
WRITE_DATA( 0, GLenum, SWAP32(mode) );
WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
CR_UNLOCK_PACKER_CONTEXT(pc);
}
void PACK_APIENTRY crPackFogfv(GLenum pname, const GLfloat *params)
{
GET_PACKER_CONTEXT(pc);
if (__handleFogData( pname, params ))
WRITE_OPCODE( pc, CR_FOGFV_OPCODE );
}
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])
{
if (length && (length[i]>=0))
{
/* include \0 in the string to make intel drivers happy */
crMemcpy(data_ptr, string[i], pLocalLength[i] - 1);
data_ptr[pLocalLength[i] - 1] = '\0';
}
else
{
/* the \0 s already in the string */
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);
}
