void SERVER_DISPATCH_APIENTRY crServerDispatchBindFramebufferEXT(GLenum target, GLuint framebuffer)
{
crStateBindFramebufferEXT(target, framebuffer);
if (0==framebuffer && crServerIsRedirectedToFBO())
{
cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, cr_server.curClient->currentMural->idFBO);
}
else
{
cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(framebuffer));
}
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchFinish(void)
{
CRContext *ctx = crStateGetCurrent();
cr_server.head_spu->dispatch_table.Finish();
if (cr_server.curClient->currentMural->bFbDraw && crServerIsRedirectedToFBO())
{
crServerPresentFBO(cr_server.curClient->currentMural);
}
if (ctx->framebufferobject.drawFB
|| (ctx->buffer.drawBuffer != GL_FRONT && ctx->buffer.drawBuffer != GL_FRONT_LEFT))
cr_server.curClient->currentMural->bFbDraw = GL_FALSE;
}
void SERVER_DISPATCH_APIENTRY crServerDispatchBindFramebufferEXT(GLenum target, GLuint framebuffer)
{
#ifdef DEBUG_misha
GLint rfb = 0, dfb = 0;
#endif
crStateBindFramebufferEXT(target, framebuffer);
if (0==framebuffer)
{
CRContext *ctx = crStateGetCurrent();
if (ctx->buffer.drawBuffer == GL_FRONT || ctx->buffer.drawBuffer == GL_FRONT_LEFT || ctx->buffer.drawBuffer == GL_FRONT_RIGHT)
cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
}
if (0==framebuffer && crServerIsRedirectedToFBO())
{
if (target == GL_FRAMEBUFFER)
{
GLuint idDrawFBO = cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurDrawBuffer];
GLuint idReadFBO = cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurReadBuffer];
if (idDrawFBO == idReadFBO)
cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_FRAMEBUFFER, idDrawFBO);
else
{
cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, idReadFBO);
cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, idDrawFBO);
}
}
else if (target == GL_READ_FRAMEBUFFER)
{
GLuint idReadFBO = cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurReadBuffer];
cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, idReadFBO);
}
else if (target == GL_DRAW_FRAMEBUFFER)
{
GLuint idDrawFBO = cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurDrawBuffer];
cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, idDrawFBO);
}
else
{
crWarning("unknown target %d", target);
}
#ifdef DEBUG_misha
cr_server.head_spu->dispatch_table.GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
cr_server.head_spu->dispatch_table.GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
if (GL_FRAMEBUFFER_EXT == target)
{
Assert(rfb == cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurReadBuffer]);
Assert(dfb == cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurDrawBuffer]);
}
else if (GL_READ_FRAMEBUFFER_EXT == target)
{
Assert(rfb == cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurReadBuffer]);
}
else if (GL_DRAW_FRAMEBUFFER_EXT == target)
{
Assert(dfb == cr_server.curClient->currentMural->aidFBOs[cr_server.curClient->currentMural->iCurDrawBuffer]);
}
else
{
Assert(0);
}
#endif
}
else
{
cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(framebuffer));
#ifdef DEBUG_misha
cr_server.head_spu->dispatch_table.GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
cr_server.head_spu->dispatch_table.GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
if (GL_FRAMEBUFFER_EXT == target)
{
Assert(rfb == crStateGetFramebufferHWID(framebuffer));
Assert(dfb == crStateGetFramebufferHWID(framebuffer));
}
else if (GL_READ_FRAMEBUFFER_EXT == target)
{
Assert(rfb == crStateGetFramebufferHWID(framebuffer));
}
else if (GL_DRAW_FRAMEBUFFER_EXT == target)
{
Assert(dfb == crStateGetFramebufferHWID(framebuffer));
}
else
{
Assert(0);
}
#endif
}
}
void SERVER_DISPATCH_APIENTRY
crServerDispatchSwapBuffers( GLint window, GLint flags )
{
CRMuralInfo *mural;
CRContext *ctx;
#ifdef VBOXCR_LOGFPS
static VBOXCRFPS Fps;
static bool bFpsInited = false;
if (!bFpsInited)
{
vboxCrFpsInit(&Fps, 64 /* cPeriods */);
bFpsInited = true;
}
vboxCrFpsReportFrame(&Fps);
if(!(vboxCrFpsGetNumFrames(&Fps) % 31))
{
double fps = vboxCrFpsGetFps(&Fps);
double bps = vboxCrFpsGetBps(&Fps);
double bpsSent = vboxCrFpsGetBpsSent(&Fps);
double cps = vboxCrFpsGetCps(&Fps);
double ops = vboxCrFpsGetOps(&Fps);
double tup = vboxCrFpsGetTimeProcPercent(&Fps);
crDebug("fps: %f, rec Mbps: %.1f, send Mbps: %.1f, cps: %.1f, ops: %.0f, host %.1f%%",
fps, bps/(1024.0*1024.0), bpsSent/(1024.0*1024.0), cps, ops, tup);
}
#endif
mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
if (!mural) {
return;
}
if (cr_server.only_swap_once)
{
/* NOTE: we only do the clear for the _last_ client in the list.
* This is because in multi-threaded apps the zeroeth client may
* be idle and never call glClear at all. See threadtest.c
* It's pretty likely that the last client will be active.
*/
if (cr_server.curClient != cr_server.clients[cr_server.numClients - 1])
{
return;
}
}
#if 0
if (cr_server.overlapBlending)
{
int a;
CRPoly *p;
GLboolean lighting, fog, blend, cull, tex[3];
GLenum mm, blendSrc, blendDst;
GLcolorf col;
CRContext *ctx = crStateGetCurrent();
const CRmatrix *baseProj;
/*
* I've probably missed some state here, or it
* might be easier just to push/pop it....
*/
lighting = ctx->lighting.lighting;
fog = ctx->fog.enable;
tex[0] = 0;
for (a=0; a<CR_MAX_TEXTURE_UNITS; a++)
{
if (!ctx->texture.unit[a].enabled1D) continue;
tex[0] = 1;
break;
}
tex[1] = 0;
for (a=0; a<CR_MAX_TEXTURE_UNITS; a++)
{
if (!ctx->texture.unit[a].enabled2D) continue;
tex[1] = 1;
break;
}
tex[2] = 0;
for (a=0; a<CR_MAX_TEXTURE_UNITS; a++)
{
if (!ctx->texture.unit[a].enabled3D) continue;
tex[2] = 1;
break;
}
cull = ctx->polygon.cullFace;
blend = ctx->buffer.blend;
blendSrc = ctx->buffer.blendSrcRGB;
blendDst = ctx->buffer.blendDstRGB;
mm = ctx->transform.matrixMode;
col.r = ctx->current.vertexAttrib[VERT_ATTRIB_COLOR0][0];
col.g = ctx->current.vertexAttrib[VERT_ATTRIB_COLOR0][1];
col.b = ctx->current.vertexAttrib[VERT_ATTRIB_COLOR0][2];
col.a = ctx->current.vertexAttrib[VERT_ATTRIB_COLOR0][3];
baseProj = &(cr_server.curClient->currentMural->extents[0].baseProjection);
switch(mm)
{
case GL_PROJECTION:
cr_server.head_spu->dispatch_table.PushMatrix();
cr_server.head_spu->dispatch_table.LoadMatrixf((GLfloat *) baseProj);
cr_server.head_spu->dispatch_table.MultMatrixf(cr_server.unnormalized_alignment_matrix);
cr_server.head_spu->dispatch_table.MatrixMode(GL_MODELVIEW);
cr_server.head_spu->dispatch_table.PushMatrix();
cr_server.head_spu->dispatch_table.LoadIdentity();
break;
default:
cr_server.head_spu->dispatch_table.MatrixMode(GL_MODELVIEW);
/* fall through */
case GL_MODELVIEW:
cr_server.head_spu->dispatch_table.PushMatrix();
cr_server.head_spu->dispatch_table.LoadIdentity();
cr_server.head_spu->dispatch_table.MatrixMode(GL_PROJECTION);
cr_server.head_spu->dispatch_table.PushMatrix();
cr_server.head_spu->dispatch_table.LoadMatrixf((GLfloat *) baseProj);
cr_server.head_spu->dispatch_table.MultMatrixf(cr_server.unnormalized_alignment_matrix);
break;
}
/* fix state */
if (lighting)
cr_server.head_spu->dispatch_table.Disable(GL_LIGHTING);
if (fog)
cr_server.head_spu->dispatch_table.Disable(GL_FOG);
if (tex[0])
cr_server.head_spu->dispatch_table.Disable(GL_TEXTURE_1D);
if (tex[1])
cr_server.head_spu->dispatch_table.Disable(GL_TEXTURE_2D);
if (tex[2])
cr_server.head_spu->dispatch_table.Disable(GL_TEXTURE_3D);
if (cull)
cr_server.head_spu->dispatch_table.Disable(GL_CULL_FACE);
/* Regular Blending */
if (cr_server.overlapBlending == 1)
{
if (!blend)
cr_server.head_spu->dispatch_table.Enable(GL_BLEND);
if ((blendSrc != GL_ZERO) && (blendDst != GL_SRC_ALPHA))
cr_server.head_spu->dispatch_table.BlendFunc(GL_ZERO, GL_SRC_ALPHA);
/* draw the blends */
for (a=1; a<cr_server.num_overlap_levels; a++)
{
if (a-1 < cr_server.num_overlap_intens)
{
cr_server.head_spu->dispatch_table.Color4f(0, 0, 0,
cr_server.overlap_intens[a-1]);
}
else
{
cr_server.head_spu->dispatch_table.Color4f(0, 0, 0, 1);
}
p = cr_server.overlap_geom[a];
while (p)
{
/* hopefully this isnt concave... */
__draw_poly(p);
p = p->next;
}
}
if (!blend)
cr_server.head_spu->dispatch_table.Disable(GL_BLEND);
if ((blendSrc != GL_ZERO) && (blendDst != GL_SRC_ALPHA))
cr_server.head_spu->dispatch_table.BlendFunc(blendSrc, blendDst);
}
else
/* Knockout Blending */
{
cr_server.head_spu->dispatch_table.Color4f(0, 0, 0, 1);
if (blend)
cr_server.head_spu->dispatch_table.Disable(GL_BLEND);
p = cr_server.overlap_knockout;
while (p)
{
__draw_poly(p);
p = p->next;
}
if (blend)
cr_server.head_spu->dispatch_table.Enable(GL_BLEND);
}
/* return things to normal */
switch (mm)
{
case GL_PROJECTION:
cr_server.head_spu->dispatch_table.PopMatrix();
cr_server.head_spu->dispatch_table.MatrixMode(GL_PROJECTION);
cr_server.head_spu->dispatch_table.PopMatrix();
break;
case GL_MODELVIEW:
cr_server.head_spu->dispatch_table.PopMatrix();
cr_server.head_spu->dispatch_table.MatrixMode(GL_MODELVIEW);
cr_server.head_spu->dispatch_table.PopMatrix();
break;
default:
cr_server.head_spu->dispatch_table.PopMatrix();
cr_server.head_spu->dispatch_table.MatrixMode(GL_MODELVIEW);
cr_server.head_spu->dispatch_table.PopMatrix();
cr_server.head_spu->dispatch_table.MatrixMode(mm);
break;
}
if (lighting)
cr_server.head_spu->dispatch_table.Enable(GL_LIGHTING);
if (fog)
cr_server.head_spu->dispatch_table.Enable(GL_FOG);
if (tex[0])
cr_server.head_spu->dispatch_table.Enable(GL_TEXTURE_1D);
if (tex[1])
cr_server.head_spu->dispatch_table.Enable(GL_TEXTURE_2D);
if (tex[2])
cr_server.head_spu->dispatch_table.Enable(GL_TEXTURE_3D);
if (cull)
cr_server.head_spu->dispatch_table.Enable(GL_CULL_FACE);
cr_server.head_spu->dispatch_table.Color4f(col.r, col.g, col.b, col.a);
}
#endif
/* Check if using a file network */
if (!cr_server.clients[0]->conn->actual_network && window == MAGIC_OFFSET)
window = 0;
ctx = crStateGetCurrent();
if (ctx->framebufferobject.drawFB
|| (ctx->buffer.drawBuffer != GL_FRONT && ctx->buffer.drawBuffer != GL_FRONT_LEFT))
cr_server.curClient->currentMural->bFbDraw = GL_FALSE;
if (crServerIsRedirectedToFBO())
{
crServerMuralFBOSwapBuffers(mural);
crServerPresentFBO(mural);
}
else
{
cr_server.head_spu->dispatch_table.SwapBuffers( mural->spuWindow, flags );
}
}
