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