void PACKSPU_APIENTRY packspu_GenTextures( GLsizei n, GLuint * textures )
{
GET_THREAD(thread);
int writeback = 1;
unsigned int i;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_GenTextures doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackGenTexturesSWAP( n, textures, &writeback );
}
else
{
crPackGenTextures( n, textures, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
for (i = 0 ; i < (unsigned int) n ; i++)
{
textures[i] = SWAP32(textures[i]);
}
}
crStateRegTextures(n, textures);
}
void PACKSPU_APIENTRY packspu_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, char * source)
{
GET_THREAD(thread);
int writeback = 1;
GLsizei *pLocal;
if (!source) return;
pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
if (!pLocal) return;
crPackGetShaderSource(shader, bufSize, pLocal, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (length) *length=*pLocal;
crMemcpy(source, &pLocal[1], (bufSize >= pLocal[0]) ? pLocal[0] : bufSize);
if (bufSize > pLocal[0])
{
source[pLocal[0]] = 0;
}
crFree(pLocal);
}
void PACKSPU_APIENTRY packspu_Finish( void )
{
GET_THREAD(thread);
GLint writeback = CRPACKSPU_IS_WDDM_CRHGSMI() ? 1 : pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network;
if (pack_spu.swap)
{
crPackFinishSWAP();
}
else
{
crPackFinish();
}
if (packspuSyncOnFlushes())
{
if (writeback)
{
if (pack_spu.swap)
crPackWritebackSWAP(&writeback);
else
crPackWriteback(&writeback);
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
}
}
GLuint PACKSPU_APIENTRY packspu_CreateProgram(void)
{
GET_THREAD(thread);
int writeback = 1;
GLuint return_val = (GLuint) 0;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError("packspu_CreateProgram doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!");
}
if (pack_spu.swap)
{
crPackCreateProgramSWAP(&return_val, &writeback);
}
else
{
crPackCreateProgram(&return_val, &writeback);
}
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
return_val = (GLuint) SWAP32(return_val);
}
crStateCreateProgram(return_val);
return return_val;
}
static GLint packspu_GetUniformLocationUncached(GLuint program, const char * name)
{
GET_THREAD(thread);
int writeback = 1;
GLint return_val = (GLint) 0;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError("packspu_GetUniformLocation doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!");
}
if (pack_spu.swap)
{
crPackGetUniformLocationSWAP(program, name, &return_val, &writeback);
}
else
{
crPackGetUniformLocation(program, name, &return_val, &writeback);
}
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
return_val = (GLint) SWAP32(return_val);
}
return return_val;
}
GLint PACKSPU_APIENTRY packspu_GetUniformLocation(GLuint program, const char * name)
{
if (!crStateIsProgramUniformsCached(program))
{
GET_THREAD(thread);
int writeback = 1;
GLsizei maxcbData;
GLsizei *pData;
GLint mu;
packspu_GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &mu);
maxcbData = 16*mu*sizeof(char);
pData = (GLsizei *) crAlloc(maxcbData+sizeof(GLsizei));
if (!pData)
{
crWarning("packspu_GetUniformLocation: not enough memory, fallback to single query");
return packspu_GetUniformLocationUncached(program, name);
}
crPackGetUniformsLocations(program, maxcbData, pData, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
crStateGLSLProgramCacheUniforms(program, pData[0], &pData[1]);
CRASSERT(crStateIsProgramUniformsCached(program));
crFree(pData);
}
/*crDebug("packspu_GetUniformLocation(%d, %s)=%i", program, name, crStateGetUniformLocation(program, name));*/
return crStateGetUniformLocation(program, name);
}
static void packspu_GetHostBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data )
{
GET_THREAD(thread);
int writeback = 1;
crPackGetBufferSubDataARB(target, offset, size, data, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
void PACKSPU_APIENTRY packspu_Flush( void )
{
GET_THREAD(thread);
int writeback=1;
int found=0;
if (!thread->bInjectThread)
{
crPackFlush();
if (packspuSyncOnFlushes())
{
crPackWriteback(&writeback);
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
}
else
{
int i;
crLockMutex(&_PackMutex);
/*Make sure we process commands in order they should appear, so flush other threads first*/
for (i=0; i<MAX_THREADS; ++i)
{
if (pack_spu.thread[i].inUse
&& (thread != &pack_spu.thread[i]) && pack_spu.thread[i].netServer.conn
&& pack_spu.thread[i].packer && pack_spu.thread[i].packer->currentBuffer)
{
packspuFlush((void *) &pack_spu.thread[i]);
if (pack_spu.thread[i].netServer.conn->u32ClientID == thread->netServer.conn->u32InjectClientID)
{
found=1;
}
}
}
if (!found)
{
/*Thread we're supposed to inject commands for has been detached,
so there's nothing to sync with and we should just pass commands through our own connection.
*/
thread->netServer.conn->u32InjectClientID=0;
}
packspuFlush((void *) thread);
crUnlockMutex(&_PackMutex);
}
}
static void GetString(GLenum name, GLubyte *pszStr)
{
GET_THREAD(thread);
int writeback = 1;
if (pack_spu.swap)
crPackGetStringSWAP(name, pszStr, &writeback);
else
crPackGetString(name, pszStr, &writeback);
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
static const GLubyte *
GetExtensions(void)
{
static GLboolean fInitialized = GL_FALSE;
if (!fInitialized)
{
GLubyte return_value[10*1000];
const GLubyte *extensions, *ext;
GET_THREAD(thread);
int writeback = 1;
if (pack_spu.swap)
{
crPackGetStringSWAP( GL_EXTENSIONS, return_value, &writeback );
}
else
{
crPackGetString( GL_EXTENSIONS, return_value, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
CRASSERT(crStrlen((char *)return_value) < 10*1000);
/* OK, we got the result from the server. Now we have to
* intersect is with the set of extensions that Chromium understands
* and tack on the Chromium-specific extensions.
*/
extensions = return_value;
ext = crStateMergeExtensions(1, &extensions);
#ifdef Linux
/*@todo
*That's a hack to allow running Unity, it uses libnux which is calling extension functions
*without checking if it's being supported/exported.
*glActiveStencilFaceEXT seems to be actually supported but the extension string isn't exported (for ex. on ATI HD4870),
*which leads to libglew setting function pointer to NULL and crashing Unity.
*/
sprintf((char*)gpszExtensions, "%s GL_EXT_stencil_two_side", ext);
#else
sprintf((char*)gpszExtensions, "%s", ext);
#endif
fInitialized = GL_TRUE;
}
return gpszExtensions;
}
GLboolean PACKSPU_APIENTRY packspu_IsEnabled(GLenum cap)
{
GLboolean res = crStateIsEnabled(cap);
#ifdef DEBUG
{
GET_THREAD(thread);
int writeback = 1;
GLboolean return_val = (GLboolean) 0;
crPackIsEnabled(cap, &return_val, &writeback);
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
CRASSERT(return_val==res);
}
#endif
return res;
}
void PACKSPU_APIENTRY packspu_GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)
{
GET_THREAD(thread);
int writeback = 1;
GLsizei *pLocal;
if (!obj) return;
pLocal = (GLsizei*) crAlloc(maxCount*sizeof(GLhandleARB)+sizeof(GLsizei));
if (!pLocal) return;
crPackGetAttachedObjectsARB(containerObj, maxCount, pLocal, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (count) *count=*pLocal;
crMemcpy(obj, &pLocal[1], *pLocal*sizeof(GLhandleARB));
crFree(pLocal);
}
GLenum PACKSPU_APIENTRY
packspu_CheckFramebufferStatusEXT(GLenum target)
{
GET_THREAD(thread);
int writeback = 1;
GLenum status = crStateCheckFramebufferStatusEXT(target);
if (status!=GL_FRAMEBUFFER_UNDEFINED)
{
return status;
}
crPackCheckFramebufferStatusEXT(target, &status, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
crStateSetFramebufferStatus(target, status);
return status;
}
void PACKSPU_APIENTRY packspu_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, char * infoLog)
{
GET_THREAD(thread);
int writeback = 1;
GLsizei *pLocal;
if (!infoLog) return;
pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
if (!pLocal) return;
crPackGetProgramInfoLog(program, bufSize, pLocal, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (length) *length=*pLocal;
crMemcpy(infoLog, &pLocal[1], (bufSize >= pLocal[0]) ? pLocal[0] : bufSize);
crFree(pLocal);
}
void PACKSPU_APIENTRY packspu_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders)
{
GET_THREAD(thread);
int writeback = 1;
GLsizei *pLocal;
if (!shaders) return;
pLocal = (GLsizei*) crAlloc(maxCount*sizeof(GLuint)+sizeof(GLsizei));
if (!pLocal) return;
crPackGetAttachedShaders(program, maxCount, pLocal, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (count) *count=*pLocal;
crMemcpy(shaders, &pLocal[1], *pLocal*sizeof(GLuint));
crFree(pLocal);
}
void PACKSPU_APIENTRY packspu_GenRenderbuffersEXT( GLsizei n, GLuint * renderbuffers )
{
GET_THREAD(thread);
int writeback = 1;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_GenRenderbuffersEXT doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackGenRenderbuffersEXTSWAP( n, renderbuffers, &writeback );
}
else
{
crPackGenRenderbuffersEXT( n, renderbuffers, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
crStateRegRenderbuffers(n, renderbuffers);
}
void PACKSPU_APIENTRY packspu_GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
{
GET_THREAD(thread);
int writeback = 1;
GLsizei *pLocal;
if (!infoLog) return;
pLocal = (GLsizei*) crAlloc(maxLength+sizeof(GLsizei));
if (!pLocal) return;
crPackGetInfoLogARB(obj, maxLength, pLocal, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
CRASSERT((pLocal[0]) <= maxLength);
if (length) *length=*pLocal;
crMemcpy(infoLog, &pLocal[1], (maxLength >= (pLocal[0])) ? pLocal[0] : maxLength);
crFree(pLocal);
}
void PACKSPU_APIENTRY packspu_GetPixelMapusv( GLenum map, GLushort * values )
{
GET_THREAD(thread);
int writeback = 1;
if (pack_spu.swap)
{
crPackGetPixelMapusvSWAP( map, values, &writeback );
}
else
{
crPackGetPixelMapusv( map, values, &writeback );
}
#ifdef CR_ARB_pixel_buffer_object
if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
#endif
{
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
}
void PACKSPU_APIENTRY packspu_GetPolygonStipple( GLubyte * mask )
{
GET_THREAD(thread);
int writeback = 1;
if (pack_spu.swap)
{
crPackGetPolygonStippleSWAP( mask, &writeback );
}
else
{
crPackGetPolygonStipple( mask, &writeback );
}
#ifdef CR_ARB_pixel_buffer_object
if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
#endif
{
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
}
void PACKSPU_APIENTRY packspu_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, char * name)
{
GET_THREAD(thread);
int writeback = 1;
crGetActive_t *pLocal;
if (!size || !type || !name) return;
pLocal = (crGetActive_t*) crAlloc(bufSize+sizeof(crGetActive_t));
if (!pLocal) return;
crPackGetActiveUniform(program, index, bufSize, (GLsizei*)pLocal, NULL, NULL, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (length) *length = pLocal->length;
*size = pLocal->size;
*type = pLocal->type;
crMemcpy(name, &pLocal[1], pLocal->length+1);
crFree(pLocal);
}
GLint PACKSPU_APIENTRY packspu_GetAttribLocation(GLuint program, const char * name)
{
if (!(CR_VBOX_CAP_GETATTRIBSLOCATIONS & g_u32VBoxHostCaps))
return packspu_GetAttribLocationUnchached(program, name);
if (!crStateIsProgramAttribsCached(program))
{
GET_THREAD(thread);
int writeback = 1;
GLsizei maxcbData;
GLsizei *pData;
GLint mu;
packspu_GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mu);
maxcbData = 4*32*mu*sizeof(char);
pData = (GLsizei *) crAlloc(maxcbData+sizeof(GLsizei));
if (!pData)
{
crWarning("packspu_GetAttribLocation: not enough memory, fallback to single query");
return packspu_GetAttribLocationUnchached(program, name);
}
crPackGetAttribsLocations(program, maxcbData, pData, NULL, &writeback);
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
crStateGLSLProgramCacheAttribs(program, pData[0], &pData[1]);
CRASSERT(crStateIsProgramAttribsCached(program));
crFree(pData);
}
/*crDebug("packspu_GetAttribLocation(%d, %s)=%i", program, name, crStateGetAttribLocation(program, name));*/
return crStateGetAttribLocation(program, name);
}
GLboolean PACKSPU_APIENTRY
packspu_AreTexturesResident( GLsizei n, const GLuint * textures,
GLboolean * residences )
{
GET_THREAD(thread);
int writeback = 1;
GLboolean return_val = GL_TRUE;
GLsizei i;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_AreTexturesResident doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackAreTexturesResidentSWAP( n, textures, residences, &return_val, &writeback );
}
else
{
crPackAreTexturesResident( n, textures, residences, &return_val, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
/* Since the Chromium packer/unpacker can't return both 'residences'
* and the function's return value, compute the return value here.
*/
for (i = 0; i < n; i++) {
if (!residences[i]) {
return_val = GL_FALSE;
break;
}
}
return return_val;
}
GLint PACKSPU_APIENTRY packspu_VBoxWindowCreate( GLint con, const char *dpyName, GLint visBits )
{
GET_THREAD(thread);
static int num_calls = 0;
int writeback = CRPACKSPU_IS_WDDM_CRHGSMI() ? 1 : pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network;
GLint return_val = (GLint) 0;
ThreadInfo *curThread = thread;
GLint retVal;
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
if (!con)
{
crError("connection expected!");
return 0;
}
thread = GET_THREAD_VAL_ID(con);
}
else
{
CRASSERT(!con);
if (!thread) {
thread = packspuNewThread(
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
NULL
#endif
);
}
}
CRASSERT(thread);
CRASSERT(thread->packer);
CRASSERT(crPackGetContext() == (curThread ? curThread->packer : NULL));
crPackSetContext(thread->packer);
if (pack_spu.swap)
{
crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback );
}
else
{
crPackWindowCreate( dpyName, visBits, &return_val, &writeback );
}
packspuFlush(thread);
if (!(thread->netServer.conn->actual_network))
{
retVal = num_calls++;
}
else
{
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
return_val = (GLint) SWAP32(return_val);
}
retVal = return_val;
}
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
if (thread != curThread)
{
if (curThread)
crPackSetContext(curThread->packer);
else
crPackSetContext(NULL);
}
}
return retVal;
}
