void STATE_APIENTRY
crStateGenBuffersARB(GLsizei n, GLuint * buffers)
{
CRContext *g = GetCurrentContext();
CRBufferObjectState *b = &(g->bufferobject);
GLint start;
FLUSH();
if (g->current.inBeginEnd) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glGenBuffersARB called in Begin/End");
return;
}
if (n < 0) {
crStateError(__LINE__, __FILE__, GL_INVALID_VALUE,
"glGenBuffersARB(n < 0)");
return;
}
start = crHashtableAllocKeys(g->shared->buffersTable, n);
if (start) {
GLint i;
for (i = 0; i < n; i++)
buffers[i] = (GLuint) (start + i);
}
else {
crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY, "glGenBuffersARB");
}
}
GLint renderspuWindowCreateEx( const char *dpyName, GLint visBits, GLint id )
{
WindowInfo *window;
VisualInfo *visual;
GLboolean showIt;
if (id <= 0)
{
id = (GLint)crHashtableAllocKeys(render_spu.windowTable, 1);
if (id <= 0)
{
crWarning("failed to allocate window id");
return -1;
}
}
else
{
if (crHashtableIsKeyUsed(render_spu.windowTable, id))
{
crWarning("the specified window key %d is in use", id);
return -1;
}
}
if (!dpyName || crStrlen(render_spu.display_string) > 0)
dpyName = render_spu.display_string;
visual = renderspuFindVisual( dpyName, visBits );
if (!visual)
{
crWarning( "Render SPU: Couldn't create a window, renderspuFindVisual returned NULL" );
return -1;
}
/* Allocate WindowInfo */
window = (WindowInfo *) crCalloc(sizeof(WindowInfo));
if (!window)
{
crWarning( "Render SPU: Couldn't create a window" );
return -1;
}
crHashtableAdd(render_spu.windowTable, id, window);
showIt = 0;
/*
crDebug("Render SPU: Creating window (visBits=0x%x, id=%d)", visBits, window->BltInfo.Base.id);
*/
/* Have GLX/WGL/AGL create the window */
if (!renderspuWindowInit( window, visual, showIt, id ))
{
crFree(window);
crWarning( "Render SPU: Couldn't create a window, renderspu_SystemCreateWindow failed" );
return -1;
}
return window->BltInfo.Base.id;
}
void STATE_APIENTRY
crStateGenQueriesARB(GLsizei n, GLuint * queries)
{
CRContext *g = GetCurrentContext();
CROcclusionState *o = &(g->occlusion);
GLint start;
FLUSH();
if (g->current.inBeginEnd) {
crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
"glGenQueriesARB called in Begin/End");
return;
}
if (n < 0) {
crStateError(__LINE__, __FILE__, GL_INVALID_VALUE,
"glGenQueriesARB(n < 0)");
return;
}
start = crHashtableAllocKeys(o->objects, n);
if (start) {
GLint i;
for (i = 0; i < n; i++)
queries[i] = (GLuint) (start + i);
}
else {
crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY, "glGenQueriesARB");
}
}
static ContextInfo * renderspuCreateContextInternal(const char *dpyName, GLint visBits, GLint idCtx, ContextInfo * sharedContext)
{
ContextInfo *context;
VisualInfo *visual;
if (idCtx <= 0)
{
idCtx = (GLint)crHashtableAllocKeys(render_spu.contextTable, 1);
if (idCtx <= 0)
{
crWarning("failed to allocate context id");
return NULL;
}
}
else
{
if (crHashtableIsKeyUsed(render_spu.contextTable, idCtx))
{
crWarning("the specified ctx key %d is in use", idCtx);
return NULL;
}
}
if (!dpyName || crStrlen(render_spu.display_string)>0)
dpyName = render_spu.display_string;
visual = renderspuFindVisual(dpyName, visBits);
if (!visual)
return NULL;
context = (ContextInfo *) crCalloc(sizeof(ContextInfo));
if (!context)
return NULL;
context->BltInfo.Base.id = idCtx;
context->shared = sharedContext;
if (!renderspu_SystemCreateContext(visual, context, sharedContext))
return NULL;
crHashtableAdd(render_spu.contextTable, idCtx, context);
context->BltInfo.Base.visualBits = visual->visAttribs;
/*
crDebug("Render SPU: CreateContext(%s, 0x%x) returning %d",
dpyName, visBits, context->BltInfo.Base.id);
*/
if (sharedContext)
ASMAtomicIncU32(&sharedContext->cRefs);
context->cRefs = 1;
return context;
}
DECLEXPORT(GLuint) STATE_APIENTRY crStateCreateProgram(GLuint hwid)
{
CRGLSLProgram *pProgram;
CRContext *g = GetCurrentContext();
GLuint stateId = hwid;
#ifdef IN_GUEST
pProgram = crStateGetProgramObj(stateId);
if (pProgram)
{
crWarning("Program object %d already exists!", stateId);
crStateDeleteProgram(stateId);
CRASSERT(!crStateGetProgramObj(stateId));
}
#else
stateId = crHashtableAllocKeys(g->glsl.programs, 1);
if (!stateId)
{
crWarning("failed to allocate program key");
return 0;
}
#endif
pProgram = (CRGLSLProgram *) crAlloc(sizeof(*pProgram));
if (!pProgram)
{
crWarning("crStateCreateProgram: Out of memory!");
return 0;
}
pProgram->id = stateId;
pProgram->hwid = hwid;
pProgram->validated = GL_FALSE;
pProgram->linked = GL_FALSE;
pProgram->deleted = GL_FALSE;
pProgram->activeState.attachedShaders = NULL;
pProgram->currentState.attachedShaders = crAllocHashtable();
pProgram->activeState.cAttribs = 0;
pProgram->activeState.pAttribs = NULL;
pProgram->currentState.cAttribs = 0;
pProgram->currentState.pAttribs = NULL;
pProgram->pUniforms = NULL;
pProgram->cUniforms = 0;
#ifdef IN_GUEST
pProgram->bUniformsSynced = GL_FALSE;
#endif
crHashtableAdd(g->glsl.programs, stateId, pProgram);
return stateId;
}
GLuint DLM_APIENTRY crDLMGenLists(GLsizei range)
{
CRDLMContextState *listState = CURRENT_STATE();
if (listState == NULL)
{
crWarning
("DLM error: GenLists(%d) called with no current state (%s line %d)\n",
(int) range, __FILE__, __LINE__);
return 0;
}
return crHashtableAllocKeys(listState->dlm->displayLists, range);
}
DECLEXPORT(GLuint) STATE_APIENTRY crStateCreateShader(GLuint hwid, GLenum type)
{
CRGLSLShader *pShader;
CRContext *g = GetCurrentContext();
GLuint stateId = hwid;
#ifdef IN_GUEST
CRASSERT(!crStateGetShaderObj(stateId));
#else
/* the proogram and shader names must not intersect because DeleteObjectARB must distinguish between them
* see crStateDeleteObjectARB
* this is why use programs table for shader keys allocation */
stateId = crHashtableAllocKeys(g->glsl.programs, 1);
if (!stateId)
{
crWarning("failed to allocate program key");
return 0;
}
Assert((pShader = crStateGetShaderObj(stateId)) == NULL);
#endif
pShader = (CRGLSLShader *) crAlloc(sizeof(*pShader));
if (!pShader)
{
crWarning("crStateCreateShader: Out of memory!");
return 0;
}
pShader->id = stateId;
pShader->hwid = hwid;
pShader->type = type;
pShader->source = NULL;
pShader->compiled = GL_FALSE;
pShader->deleted = GL_FALSE;
pShader->refCount = 0;
crHashtableAdd(g->glsl.shaders, stateId, pShader);
return stateId;
}
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;
dpyName = "";
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->currentMural = NULL;
pContextInfo->CreateInfo.requestedVisualBits = visualBits;
if (cr_server.fVisualBitsDefault)
visualBits = cr_server.fVisualBitsDefault;
pContextInfo->CreateInfo.realVisualBits = 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.realVisualBits = visualBits;
cr_server.MainContextInfo.SpuContext = cr_server.head_spu->dispatch_table.
CreateContext(dpyName, cr_server.MainContextInfo.CreateInfo.realVisualBits, shareCtx);
if (cr_server.MainContextInfo.SpuContext < 0) {
crWarning("crServerDispatchCreateContext() failed.");
crFree(pContextInfo);
return -1;
}
cr_server.MainContextInfo.pContext = crStateCreateContext(&cr_server.limits, visualBits, NULL);
CRASSERT(cr_server.MainContextInfo.pContext);
cr_server.firstCallCreateContext = GL_FALSE;
fFirst = GL_TRUE;
cr_server.head_spu->dispatch_table.ChromiumParameteriCR(GL_HH_SET_DEFAULT_SHARED_CTX, cr_server.MainContextInfo.SpuContext);
}
else {
/* second or third or ... context */
if (!cr_server.bUseMultipleContexts && ((visualBits & cr_server.MainContextInfo.CreateInfo.realVisualBits) != visualBits)) {
int oldSpuContext;
/* should never be here */
CRASSERT(0);
/* the new context needs new visual attributes */
cr_server.MainContextInfo.CreateInfo.realVisualBits |= visualBits;
crWarning("crServerDispatchCreateContext requires new visual (0x%x).",
cr_server.MainContextInfo.CreateInfo.realVisualBits);
/* 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.realVisualBits, 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;
}
/* we do not need to clean up the old default context explicitly, since the above cr_server.head_spu->dispatch_table.DestroyContext call
* will do that for us */
cr_server.head_spu->dispatch_table.ChromiumParameteriCR(GL_HH_SET_DEFAULT_SHARED_CTX, cr_server.MainContextInfo.SpuContext);
}
}
if (cr_server.bUseMultipleContexts) {
pContextInfo->SpuContext = cr_server.head_spu->dispatch_table.
CreateContext(dpyName, cr_server.MainContextInfo.CreateInfo.realVisualBits, 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 ? (GLint)crHashtableAllocKeys( cr_server.contextTable, 1 ) : preloadCtxID;
pContextInfo->pContext = newCtx;
Assert(pContextInfo->CreateInfo.realVisualBits == 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;
}
}
}
crServerReturnValue( &retVal, sizeof(retVal) );
return retVal;
}
/**
* Generate host and guest IDs, setup IDs mapping between host and guest.
*/
GLuint DLM_APIENTRY crDLMGenLists(GLsizei range, SPUDispatchTable *dispatchTable)
{
CRDLMContextState *listState = CURRENT_STATE();
GLuint idHostRangeStart = 0;
GLuint idGuestRangeStart = 0;
crDebug("DLM: GenLists(%d) (DLM=%p).", range, listState ? listState->dlm : 0);
if (listState)
{
idHostRangeStart = dispatchTable->GenLists(range);
if (idHostRangeStart > 0)
{
idGuestRangeStart = crHashtableAllocKeys(listState->dlm->displayLists, range);
if (idGuestRangeStart > 0)
{
GLuint i;
bool fSuccess = true;
/* Now have successfully generated IDs range for host and guest. Let's make IDs association. */
for (i = 0; i < (GLuint)range; i++)
{
DLMListInfo *pListInfo;
pListInfo = (DLMListInfo *)crCalloc(sizeof(DLMListInfo));
if (pListInfo)
{
crMemset(pListInfo, 0, sizeof(DLMListInfo));
pListInfo->hwid = idHostRangeStart + i;
/* Insert pre-initialized list data which contains IDs mapping into the hash. */
crHashtableReplace(listState->dlm->displayLists, idGuestRangeStart + i, pListInfo, NULL);
}
else
{
fSuccess = false;
break;
}
}
/* All structures allocated and initialized successfully. */
if (fSuccess)
return idGuestRangeStart;
/* Rollback some data was not allocated. */
crDLMDeleteLists(idGuestRangeStart, range, NULL /* we do DeleteLists() later in this routine */ );
}
else
crDebug("DLM: Can't allocate Display List IDs range for the guest.");
dispatchTable->DeleteLists(idHostRangeStart, range);
}
else
crDebug("DLM: Can't allocate Display List IDs range on the host side.");
}
else
crDebug("DLM: GenLists(%u) called with no current state.", range);
/* Can't reserve IDs range. */
return 0;
}