void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedObjectsARB(VBoxGLhandleARB containerObj, GLsizei maxCount, GLsizei * count, VBoxGLhandleARB * obj)
{
GLsizei *pLocal;
pLocal = (GLsizei*) crAlloc(maxCount*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
/* initial (fallback )value */
*pLocal = 0;
cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(containerObj), maxCount, pLocal, (VBoxGLhandleARB*)&pLocal[1]);
{
GLsizei i;
GLuint *ids=(GLuint*)&pLocal[1];
for (i=0; i<*pLocal; ++i)
ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
}
crServerReturnValue(pLocal, (*pLocal)*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
{
GLsizei *pLocal;
pLocal = (GLsizei*) crAlloc(maxCount*sizeof(GLuint)+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
/* initial (fallback )value */
*pLocal = 0;
cr_server.head_spu->dispatch_table.GetAttachedShaders(crStateGetProgramHWID(program), maxCount, pLocal, (GLuint*)&pLocal[1]);
{
GLsizei i;
GLuint *ids=(GLuint*)&pLocal[1];
for (i=0; i<*pLocal; ++i);
ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
}
crServerReturnValue(pLocal, (*pLocal)*sizeof(GLuint)+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog)
{
GLsizei *pLocal;
pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
cr_server.head_spu->dispatch_table.GetShaderInfoLog(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, char *name)
{
crGetActive_t *pLocal;
pLocal = (crGetActive_t*) crAlloc(bufSize+sizeof(crGetActive_t));
if (!pLocal)
{
crGetActive_t zero;
zero.length = 0;
crServerReturnValue(&zero, sizeof(zero));
}
cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
crFree(pLocal);
}
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsRenderbufferEXT( GLuint renderbuffer )
{
GLboolean retval;
retval = cr_server.head_spu->dispatch_table.IsRenderbufferEXT(crStateGetRenderbufferHWID(renderbuffer));
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
GLboolean SERVER_DISPATCH_APIENTRY
crServerDispatchAreProgramsResidentNV(GLsizei n, const GLuint *programs,
GLboolean *residences)
{
GLboolean retval;
GLboolean *res = (GLboolean *) crAlloc(n * sizeof(GLboolean));
GLsizei i;
(void) residences;
if (!cr_server.sharedTextureObjects) {
GLuint *programs2 = (GLuint *) crAlloc(n * sizeof(GLuint));
for (i = 0; i < n; i++)
programs2[i] = crServerTranslateProgramID(programs[i]);
retval = cr_server.head_spu->dispatch_table.AreProgramsResidentNV(n, programs2, res);
crFree(programs2);
}
else {
retval = cr_server.head_spu->dispatch_table.AreProgramsResidentNV(n, programs, res);
}
crServerReturnValue(res, n * sizeof(GLboolean));
crFree(res);
return retval; /* WILL PROBABLY BE IGNORED */
}
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsShader(GLuint shader)
{
GLboolean retval;
retval = cr_server.head_spu->dispatch_table.IsShader(crStateGetShaderHWID(shader));
crServerReturnValue(&retval, sizeof(retval));
return retval; /* ignored */
}
GLint SERVER_DISPATCH_APIENTRY crServerDispatchGetUniformLocation(GLuint program, const char * name)
{
GLint retval;
retval = cr_server.head_spu->dispatch_table.GetUniformLocation(crStateGetProgramHWID(program), name);
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
GLboolean SERVER_DISPATCH_APIENTRY
crServerDispatchAreTexturesResident(GLsizei n, const GLuint *textures,
GLboolean *residences)
{
GLboolean retval;
GLsizei i;
GLboolean *res = (GLboolean *) crAlloc(n * sizeof(GLboolean));
GLuint *textures2 = (GLuint *) crAlloc(n * sizeof(GLuint));
(void) residences;
for (i = 0; i < n; i++)
{
textures2[i] = crStateGetTextureHWID(textures[i]);
}
retval = cr_server.head_spu->dispatch_table.AreTexturesResident(n, textures2, res);
crFree(textures2);
crServerReturnValue(res, n * sizeof(GLboolean));
crFree(res);
return retval; /* WILL PROBABLY BE IGNORED */
}
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsProgram(GLuint program)
{
GLboolean retval;
retval = cr_server.head_spu->dispatch_table.IsProgram(crStateGetProgramHWID(program));
crServerReturnValue(&retval, sizeof(retval));
return retval; /* ignored */
}
/*@todo will fail for textures loaded from snapshot */
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsTexture( GLuint texture )
{
GLboolean retval;
retval = cr_server.head_spu->dispatch_table.IsTexture(crStateGetTextureHWID(texture));
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, char *name)
{
crGetActive_t *pLocal;
pLocal = (crGetActive_t*) crAlloc(bufSize+sizeof(crGetActive_t));
if (!pLocal)
{
crGetActive_t zero;
zero.length = 0;
crServerReturnValue(&zero, sizeof(zero));
}
/* zero out just the header to ensure it initially contains zero size values */
memset(pLocal, 0, sizeof (*pLocal));
cr_server.head_spu->dispatch_table.GetActiveAttrib(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
crFree(pLocal);
}
GLuint SERVER_DISPATCH_APIENTRY crServerDispatchCreateShader(GLenum type)
{
GLuint retval;
retval = cr_server.head_spu->dispatch_table.CreateShader(type);
crStateCreateShader(retval, type);
crServerReturnValue(&retval, sizeof(retval));
return retval; /* ignored */
}
GLuint SERVER_DISPATCH_APIENTRY crServerDispatchCreateProgram(void)
{
GLuint retval;
retval = cr_server.head_spu->dispatch_table.CreateProgram();
crStateCreateProgram(retval);
crServerReturnValue(&retval, sizeof(retval));
return retval; /* ignored */
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, char *source)
{
GLsizei *pLocal;
pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
/* initial (fallback )value */
*pLocal = 0;
cr_server.head_spu->dispatch_table.GetShaderSource(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
CRASSERT(pLocal[0] <= bufSize);
crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetUniformiv(GLuint program, GLint location, GLint *params)
{
int size = __GetUniformSize(program, location) * sizeof(GLint);
GLint *pLocal;
pLocal = (GLint*) crAlloc(size);
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
cr_server.head_spu->dispatch_table.GetUniformiv(crStateGetProgramHWID(program), location, pLocal);
crServerReturnValue(pLocal, size);
crFree(pLocal);
}
/*@todo will fail for progs loaded from snapshot */
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsProgramARB( GLuint program )
{
GLboolean retval;
program = crServerTranslateProgramID(program);
retval = cr_server.head_spu->dispatch_table.IsProgramARB( program );
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsList( GLuint list )
{
GLboolean retval;
list = TranslateListID( list );
retval = cr_server.head_spu->dispatch_table.IsList( list );
crServerReturnValue( &retval, sizeof(retval) );
return retval;
}
GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsRenderbufferEXT( GLuint renderbuffer )
{
/* since GenFramebuffers/Renderbuffers issued to host ogl only on bind + some other ops, the host drivers may not know about them
* so use state data*/
GLboolean retval = crStateIsRenderbufferEXT(renderbuffer);
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGenQueriesARB(GLsizei n, GLuint *queries)
{
GLuint *local_queries = (GLuint *) crAlloc( n * sizeof(*local_queries) );
(void) queries;
cr_server.head_spu->dispatch_table.GenQueriesARB( n, local_queries );
crServerReturnValue( local_queries, n * sizeof(*local_queries) );
crFree( local_queries );
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers)
{
GLuint *local_buffers = (GLuint *) crAlloc(n * sizeof(*local_buffers));
(void) renderbuffers;
cr_server.head_spu->dispatch_table.GenFramebuffersEXT(n, local_buffers);
crServerReturnValue(local_buffers, n * sizeof(*local_buffers));
crFree(local_buffers);
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)
{
GLint local_params[1];
(void) params;
crStateGetFramebufferAttachmentParameterivEXT(target, attachment, pname, local_params);
crServerReturnValue(&(local_params[0]), 1*sizeof(GLint));
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
{
GLsizei *pLocal;
GLuint hwid;
pLocal = (GLsizei*) crAlloc(maxLength+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
/*@todo: recheck*/
hwid = crStateGetProgramHWID(obj);
if (!hwid) hwid = crStateGetShaderHWID(obj);
cr_server.head_spu->dispatch_table.GetInfoLogARB(hwid, maxLength, pLocal, (char*)&pLocal[1]);
crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGenBuffersARB(GLsizei n, GLuint *buffers)
{
GLuint *local_buffers = (GLuint *) crAlloc( n * sizeof(*local_buffers) );
(void) buffers;
crStateGenBuffersARB(n, local_buffers);
crServerReturnValue( local_buffers, n * sizeof(*local_buffers) );
crFree( local_buffers );
}
GLhandleARB SERVER_DISPATCH_APIENTRY crServerDispatchGetHandleARB( GLenum pname )
{
GLhandleARB retval;
retval = cr_server.head_spu->dispatch_table.GetHandleARB(pname);
if (pname==GL_PROGRAM_OBJECT_ARB)
{
retval = crStateGLSLProgramHWIDtoID(retval);
}
crServerReturnValue( &retval, sizeof(retval) );
return retval; /* WILL PROBABLY BE IGNORED */
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGetUniformsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
{
GLsizei *pLocal;
(void) cbData;
(void) pData;
pLocal = (GLsizei*) crAlloc(maxcbData+sizeof(GLsizei));
if (!pLocal)
{
GLsizei zero=0;
crServerReturnValue(&zero, sizeof(zero));
}
crStateGLSLProgramCacheUniforms(program, maxcbData, pLocal, (char*)&pLocal[1]);
crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
crFree(pLocal);
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint * params )
{
GLint local_params[1];
GLuint hwid = crStateGetProgramHWID(obj);
if (!hwid)
{
hwid = crStateGetShaderHWID(obj);
if (!hwid)
{
crWarning("Unknown object %i, in crServerDispatchGetObjectParameterivARB", obj);
}
}
(void) params;
cr_server.head_spu->dispatch_table.GetObjectParameterivARB( hwid, pname, local_params );
crServerReturnValue( &(local_params[0]), 1*sizeof(GLint) );
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchGetBufferSubDataARB(GLenum target, GLintptrARB offset,
GLsizeiptrARB size, void * data)
{
void *b;
b = crAlloc(size);
if (b) {
cr_server.head_spu->dispatch_table.GetBufferSubDataARB( target, offset, size, b );
crServerReturnValue( b, size );
crFree( b );
}
else {
crError("Out of memory in crServerDispatchGetBufferSubDataARB");
}
}
GLint crServerDispatchCreateContextEx(const char *dpyName, GLint visualBits, GLint shareCtx, GLint preloadCtxID, int32_t internalID)
{
GLint retVal = -1;
CRContext *newCtx;
CRContextInfo *pContextInfo;
GLboolean fFirst = GL_FALSE;
if (shareCtx > 0) {
crWarning("CRServer: context sharing not implemented.");
shareCtx = 0;
}
pContextInfo = (CRContextInfo *) crAlloc(sizeof (CRContextInfo));
if (!pContextInfo)
{
crWarning("failed to alloc context info!");
return -1;
}
pContextInfo->CreateInfo.visualBits = visualBits;
/* Since the Cr server serialized all incoming clients/contexts into
* one outgoing GL stream, we only need to create one context for the
* head SPU. We'll only have to make it current once too, below.
*/
if (cr_server.firstCallCreateContext) {
cr_server.MainContextInfo.CreateInfo.visualBits = visualBits;
cr_server.MainContextInfo.SpuContext = cr_server.head_spu->dispatch_table.
CreateContext(dpyName, cr_server.MainContextInfo.CreateInfo.visualBits, shareCtx);
if (cr_server.MainContextInfo.SpuContext < 0) {
crWarning("crServerDispatchCreateContext() failed.");
crFree(pContextInfo);
return -1;
}
cr_server.firstCallCreateContext = GL_FALSE;
fFirst = GL_TRUE;
}
else {
/* second or third or ... context */
if (!cr_server.bUseMultipleContexts && ((visualBits & cr_server.MainContextInfo.CreateInfo.visualBits) != visualBits)) {
int oldSpuContext;
/* the new context needs new visual attributes */
cr_server.MainContextInfo.CreateInfo.visualBits |= visualBits;
crDebug("crServerDispatchCreateContext requires new visual (0x%x).",
cr_server.MainContextInfo.CreateInfo.visualBits);
/* Here, we used to just destroy the old rendering context.
* Unfortunately, this had the side effect of destroying
* all display lists and textures that had been loaded on
* the old context as well.
*
* Now, first try to create a new context, with a suitable
* visual, sharing display lists and textures with the
* old context. Then destroy the old context.
*/
/* create new rendering context with suitable visual */
oldSpuContext = cr_server.MainContextInfo.SpuContext;
cr_server.MainContextInfo.SpuContext = cr_server.head_spu->dispatch_table.
CreateContext(dpyName, cr_server.MainContextInfo.CreateInfo.visualBits, cr_server.MainContextInfo.SpuContext);
/* destroy old rendering context */
cr_server.head_spu->dispatch_table.DestroyContext(oldSpuContext);
if (cr_server.MainContextInfo.SpuContext < 0) {
crWarning("crServerDispatchCreateContext() failed.");
crFree(pContextInfo);
return -1;
}
}
}
if (cr_server.bUseMultipleContexts) {
pContextInfo->SpuContext = cr_server.head_spu->dispatch_table.
CreateContext(dpyName, cr_server.MainContextInfo.CreateInfo.visualBits, cr_server.MainContextInfo.SpuContext);
if (pContextInfo->SpuContext < 0) {
crWarning("crServerDispatchCreateContext() failed.");
crStateEnableDiffOnMakeCurrent(GL_TRUE);
cr_server.bUseMultipleContexts = GL_FALSE;
if (!fFirst)
crError("creating shared context failed, while it is expected to work!");
}
else if (fFirst)
{
crStateEnableDiffOnMakeCurrent(GL_FALSE);
}
}
else
{
pContextInfo->SpuContext = -1;
}
/* Now create a new state-tracker context and initialize the
* dispatch function pointers.
*/
newCtx = crStateCreateContextEx(&cr_server.limits, visualBits, NULL, internalID);
if (newCtx) {
crStateSetCurrentPointers( newCtx, &(cr_server.current) );
crStateResetCurrentPointers(&(cr_server.current));
retVal = preloadCtxID<0 ? crServerGenerateID(&cr_server.idsPool.freeContextID) : preloadCtxID;
pContextInfo->pContext = newCtx;
pContextInfo->CreateInfo.visualBits = visualBits;
pContextInfo->CreateInfo.externalID = retVal;
pContextInfo->CreateInfo.pszDpyName = dpyName ? crStrdup(dpyName) : NULL;
crHashtableAdd(cr_server.contextTable, retVal, pContextInfo);
}
if (retVal != -1 && !cr_server.bIsInLoadingState) {
int pos;
for (pos = 0; pos < CR_MAX_CONTEXTS; pos++) {
if (cr_server.curClient->contextList[pos] == 0) {
cr_server.curClient->contextList[pos] = retVal;
break;
}
}
}
{
/* As we're using only one host context to serve all client contexts, newly created context will still
* hold last error value from any previous failed opengl call. Proper solution would be to redirect any
* client glGetError calls to our state tracker, but right now it's missing quite a lot of checks and doesn't
* reflect host driver/gpu specific issues. Thus we just reset last opengl error at context creation.
*/
GLint err;
err = cr_server.head_spu->dispatch_table.GetError();
if (err!=GL_NO_ERROR)
{
#ifdef DEBUG_misha
crDebug("Cleared gl error %#x on context creation", err);
#else
crWarning("Cleared gl error %#x on context creation", err);
#endif
}
}
crServerReturnValue( &retVal, sizeof(retVal) );
return retVal;
}
void SERVER_DISPATCH_APIENTRY crServerDispatchGetMapdv( GLenum target, GLenum query, GLdouble *v )
{
GLdouble *coeffs = NULL;
GLdouble order[2];
GLdouble domain[4];
GLdouble *retptr = NULL;
GLint tempOrder[2];
int dimension = 0;
unsigned int size = sizeof(GLdouble);
int evalcomp = __evaluator_components(target);
(void) v;
switch( target )
{
case GL_MAP1_COLOR_4:
case GL_MAP1_INDEX:
case GL_MAP1_NORMAL:
case GL_MAP1_TEXTURE_COORD_1:
case GL_MAP1_TEXTURE_COORD_2:
case GL_MAP1_TEXTURE_COORD_3:
case GL_MAP1_TEXTURE_COORD_4:
case GL_MAP1_VERTEX_3:
case GL_MAP1_VERTEX_4:
dimension = 1;
break;
case GL_MAP2_COLOR_4:
case GL_MAP2_INDEX:
case GL_MAP2_NORMAL:
case GL_MAP2_TEXTURE_COORD_1:
case GL_MAP2_TEXTURE_COORD_2:
case GL_MAP2_TEXTURE_COORD_3:
case GL_MAP2_TEXTURE_COORD_4:
case GL_MAP2_VERTEX_3:
case GL_MAP2_VERTEX_4:
dimension = 2;
break;
default:
crError( "Bad target in crServerDispatchGetMapdv: %d", target );
break;
}
switch(query)
{
case GL_ORDER:
cr_server.head_spu->dispatch_table.GetMapdv( target, query, order );
retptr = &(order[0]);
size *= dimension;
break;
case GL_DOMAIN:
cr_server.head_spu->dispatch_table.GetMapdv( target, query, domain );
retptr = &(domain[0]);
size *= dimension * 2;
break;
case GL_COEFF:
cr_server.head_spu->dispatch_table.GetMapiv( target, GL_ORDER, tempOrder );
size *= evalcomp * tempOrder[0];
if (dimension == 2)
size *= tempOrder[1];
coeffs = (GLdouble *) crAlloc( size );
cr_server.head_spu->dispatch_table.GetMapdv( target, query, coeffs );
retptr = coeffs;
break;
default:
crError( "Bad query in crServerDispatchGetMapdv: %d", query );
break;
}
crServerReturnValue( retptr, size );
if (query == GL_COEFF)
{
crFree(coeffs);
}
}
