/**
* @brief RB_Finish
* @param[in] data
* @return
*/
const void *RB_Finish(const void *data)
{
const renderFinishCommand_t *cmd = ( const renderFinishCommand_t * ) data;
//ri.Printf( PRINT_ALL, "RB_Finish\n" );
qglFinish();
return ( const void * ) (cmd + 1);
}
/**
* @brief RB_SwapBuffers
* @param[in] data
* @return
*/
const void *RB_SwapBuffers(const void *data)
{
const swapBuffersCommand_t *cmd;
// finish any 2D drawing if needed
if (tess.numIndexes)
{
RB_EndSurface();
}
// texture swapping test
if (r_showImages->integer)
{
RB_ShowImages();
}
RB_GammaScreen();
cmd = ( const swapBuffersCommand_t * ) data;
// we measure overdraw by reading back the stencil buffer and
// counting up the number of increments that have happened
if (r_measureOverdraw->integer)
{
int i;
long sum = 0;
unsigned char *stencilReadback;
stencilReadback = ri.Hunk_AllocateTempMemory(glConfig.vidWidth * glConfig.vidHeight);
qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencilReadback);
for (i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++)
{
sum += stencilReadback[i];
}
backEnd.pc.c_overDraw += sum;
ri.Hunk_FreeTempMemory(stencilReadback);
}
if (!glState.finishCalled)
{
qglFinish();
}
Ren_LogComment("***************** RB_SwapBuffers *****************\n\n\n");
ri.GLimp_SwapFrame();
backEnd.projection2D = qfalse;
return ( const void * ) (cmd + 1);
}
/*
===================
GLimp_DeactivateContext
===================
*/
void GLimp_DeactivateContext( void ) {
qglFinish();
if ( !qwglMakeCurrent( win32.hDC, NULL ) ) {
win32.wglErrors++;
}
#ifdef REALLOC_DC
// makeCurrent NULL frees the DC, so get another
if ( ( win32.hDC = GetDC( win32.hWnd ) ) == NULL ) {
win32.wglErrors++;
}
#endif
}
/*
=================
RadiantInit
This is also called when you 'quit' in doom
=================
*/
void RadiantInit( void ) {
// make sure the renderer is initialized
if ( !renderSystem->IsOpenGLRunning() ) {
common->Printf( "no OpenGL running\n" );
return;
}
g_editorAlive = true;
// allocate a renderWorld and a soundWorld
if ( g_qeglobals.rw == NULL ) {
g_qeglobals.rw = renderSystem->AllocRenderWorld();
g_qeglobals.rw->InitFromMap( NULL );
}
if ( g_qeglobals.sw == NULL ) {
g_qeglobals.sw = soundSystem->AllocSoundWorld( g_qeglobals.rw );
}
if ( g_DoomInstance ) {
if ( ::IsWindowVisible( win32.hWnd ) ) {
::ShowWindow( win32.hWnd, SW_HIDE );
g_pParentWnd->ShowWindow( SW_SHOW );
g_pParentWnd->SetFocus();
}
} else {
Sys_GrabMouseCursor( false );
g_DoomInstance = win32.hInstance;
CWinApp* pApp = AfxGetApp();
CWinThread *pThread = AfxGetThread();
InitAfx();
// App global initializations (rare)
pApp->InitApplication();
// Perform specific initializations
pThread->InitInstance();
qglFinish();
//qwglMakeCurrent(0, 0);
qwglMakeCurrent(win32.hDC, win32.hGLRC);
// hide the doom window by default
::ShowWindow( win32.hWnd, SW_HIDE );
}
}
/*
=============
RB_SwapBuffers
=============
*/
const void RB_SwapBuffers( const void *data ) {
// texture swapping test
if ( r_showImages.GetInteger() != 0 ) {
RB_ShowImages();
}
// force a gl sync if requested
if ( r_finish.GetBool() ) {
qglFinish();
}
RB_LogComment( "***************** RB_SwapBuffers *****************\n\n\n" );
// don't flip if drawing to front buffer
if ( !r_frontBuffer.GetBool() ) {
GLimp_SwapBuffers();
}
}
/*
* R_EndOcclusionPass
*/
void R_EndOcclusionPass( void )
{
assert( OCCLUSION_QUERIES_ENABLED( ri ) );
R_RenderOccludingSurfaces();
R_SurfIssueOcclusionQueries();
R_BackendResetPassMask();
R_BackendResetCounters();
if( r_occlusion_queries_finish->integer )
qglFinish();
else
qglFlush();
qglEnable( GL_TEXTURE_2D );
}
/*
========================
GLimp_TestSwapBuffers
========================
*/
void GLimp_TestSwapBuffers( const idCmdArgs& args )
{
idLib::Printf( "GLimp_TimeSwapBuffers\n" );
static const int MAX_FRAMES = 5;
uint64 timestamps[MAX_FRAMES];
qglDisable( GL_SCISSOR_TEST );
int frameMilliseconds = 16;
for( int swapInterval = 2 ; swapInterval >= -1 ; swapInterval-- )
{
wglSwapIntervalEXT( swapInterval );
for( int i = 0 ; i < MAX_FRAMES ; i++ )
{
if( swapInterval == -1 )
{
Sys_Sleep( frameMilliseconds );
}
if( i & 1 )
{
qglClearColor( 0, 1, 0, 1 );
}
else
{
qglClearColor( 1, 0, 0, 1 );
}
qglClear( GL_COLOR_BUFFER_BIT );
qwglSwapBuffers( win32.hDC );
qglFinish();
timestamps[i] = Sys_Microseconds();
}
idLib::Printf( "\nswapinterval %i\n", swapInterval );
for( int i = 1 ; i < MAX_FRAMES ; i++ )
{
idLib::Printf( "%i microseconds\n", ( int )( timestamps[i] - timestamps[i - 1] ) );
}
}
}
/*
** GLimp_EndFrame
**
** Responsible for doing a swapbuffers and possibly for other stuff
** as yet to be determined. Probably better not to make this a GLimp
** function and instead do a call to GLimp_SwapBuffers.
*/
void GLimp_EndFrame (void)
{
#if 0
int err;
if ( !glState.finishCalled )
qglFinish();
// check for errors
if ( !gl_ignore_errors->value ) {
if ( ( err = qglGetError() ) != GL_NO_ERROR )
{
ri.Error( ERR_FATAL, "GLimp_EndFrame() - glGetError() failed (0x%x)!\n", err );
}
}
#endif
// don't flip if drawing to front buffer
if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
{
qglXSwapBuffers(dpy, win);
}
// check logging
QGL_EnableLogging( r_logFile->value );
#if 0
GLimp_LogComment( "*** RE_EndFrame ***\n" );
// decrement log
if ( gl_log->value )
{
ri.Cvar_Set( "gl_log", va("%i",gl_log->value - 1 ) );
}
#endif
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
void RB_BeginDrawingView (void) {
int clearBits = 0;
// sync with gl if needed
if ( r_finish->integer == 1 && !glState.finishCalled ) {
qglFinish ();
glState.finishCalled = qtrue;
}
if ( r_finish->integer == 0 ) {
glState.finishCalled = qtrue;
}
// we will need to change the projection matrix before drawing
// 2D images again
backEnd.projection2D = qfalse;
if (glRefConfig.framebufferObject)
{
FBO_t *fbo = backEnd.viewParms.targetFbo;
// FIXME: HUGE HACK: render to the screen fbo if we've already postprocessed the frame and aren't drawing more world
// drawing more world check is in case of double renders, such as skyportals
if (fbo == NULL && !(backEnd.framePostProcessed && (backEnd.refdef.rdflags & RDF_NOWORLDMODEL)))
fbo = tr.renderFbo;
if (tr.renderCubeFbo && fbo == tr.renderCubeFbo)
{
cubemap_t *cubemap = &tr.cubemaps[backEnd.viewParms.targetFboCubemapIndex];
FBO_AttachImage(fbo, cubemap->image, GL_COLOR_ATTACHMENT0_EXT, backEnd.viewParms.targetFboLayer);
}
FBO_Bind(fbo);
}
//
// set the modelview matrix for the viewer
//
SetViewportAndScissor();
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// clear relevant buffers
clearBits = GL_DEPTH_BUFFER_BIT;
if ( r_measureOverdraw->integer || r_shadows->integer == 2 )
{
clearBits |= GL_STENCIL_BUFFER_BIT;
}
if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) )
{
clearBits |= GL_COLOR_BUFFER_BIT; // FIXME: only if sky shaders have been used
}
// clear to black for cube maps
if (tr.renderCubeFbo && backEnd.viewParms.targetFbo == tr.renderCubeFbo)
{
clearBits |= GL_COLOR_BUFFER_BIT;
}
qglClear( clearBits );
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
{
RB_Hyperspace();
return;
}
else
{
backEnd.isHyperspace = qfalse;
}
// we will only draw a sun if there was sky rendered in this view
backEnd.skyRenderedThisView = qfalse;
// clip to the plane of the portal
if ( backEnd.viewParms.isPortal ) {
#if 0
float plane[4];
GLdouble plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane);
plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane);
plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane);
plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3];
#endif
GL_SetModelviewMatrix( s_flipMatrix );
}
}
/*
* RB_BeginDrawingView
*
* Any mirrored or portaled views have already been drawn, so prepare
* to actually render the visible surfaces for this view
*/
void
RB_BeginDrawingView(void)
{
int clearBits = 0;
/* sync with gl if needed */
if(r_finish->integer == 1 && !glState.finishCalled){
qglFinish ();
glState.finishCalled = qtrue;
}
if(r_finish->integer == 0){
glState.finishCalled = qtrue;
}
/* we will need to change the projection matrix before drawing
* 2D images again */
backEnd.projection2D = qfalse;
if(glRefConfig.framebufferObject){
/* FIXME: HUGE HACK: render to the screen fbo if we've already postprocessed the frame and aren't drawing more world */
if(backEnd.viewParms.targetFbo == tr.renderFbo && backEnd.framePostProcessed &&
(backEnd.refdef.rdflags & RDF_NOWORLDMODEL)){
FBO_Bind(tr.screenScratchFbo);
}else{
FBO_Bind(backEnd.viewParms.targetFbo);
}
}
/*
* set the modelview matrix for the viewer
* */
SetViewportAndScissor();
/* ensures that depth writes are enabled for the depth clear */
GL_State(GLS_DEFAULT);
/* clear relevant buffers */
clearBits = GL_DEPTH_BUFFER_BIT;
if(r_measureOverdraw->integer || r_shadows->integer == 2){
clearBits |= GL_STENCIL_BUFFER_BIT;
}
if(r_fastsky->integer && !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL)){
clearBits |= GL_COLOR_BUFFER_BIT; /* FIXME: only if sky shaders have been used */
#ifdef _DEBUG
qglClearColor(0.8f, 0.7f, 0.4f, 1.0f); /* FIXME: get color of sky */
#else
qglClearColor(0.0f, 0.0f, 0.0f, 1.0f); /* FIXME: get color of sky */
#endif
}
/* clear to white for shadow maps */
if(backEnd.viewParms.isShadowmap){
clearBits |= GL_COLOR_BUFFER_BIT;
qglClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}
qglClear(clearBits);
if((backEnd.refdef.rdflags & RDF_HYPERSPACE)){
RB_Hyperspace();
return;
}else{
backEnd.isHyperspace = qfalse;
}
glState.faceCulling = -1; /* force face culling to set next time */
/* we will only draw a sun if there was sky rendered in this view */
backEnd.skyRenderedThisView = qfalse;
#ifdef REACTION
backEnd.hasSunFlare = qfalse;
#endif
/* clip to the plane of the portal */
if(backEnd.viewParms.isPortal){
float plane[4];
double plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = dotv3 (backEnd.viewParms.or.axis[0], plane);
plane2[1] = dotv3 (backEnd.viewParms.or.axis[1], plane);
plane2[2] = dotv3 (backEnd.viewParms.or.axis[2], plane);
plane2[3] = dotv3 (plane, backEnd.viewParms.or.origin) - plane[3];
GL_SetModelviewMatrix(s_flipMatrix);
}
}
/*
* RE_StretchRaw
*
* FIXME: not exactly backend
* Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
* Used for cinematics.
*/
void
RE_StretchRaw(int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qbool dirty)
{
int i, j;
int start, end;
shaderProgram_t *sp = &tr.textureColorShader;
Vec4 color;
if(!tr.registered){
return;
}
R_SyncRenderThread();
/* we definately want to sync every frame for the cinematics */
qglFinish();
start = 0;
if(r_speeds->integer){
start = ri.Milliseconds();
}
/* make sure rows and cols are powers of 2 */
for(i = 0; (1 << i) < cols; i++){
}
for(j = 0; (1 << j) < rows; j++){
}
if((1 << i) != cols || (1 << j) != rows){
ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
}
GL_Bind(tr.scratchImage[client]);
/* if the scratchImage isn't in the format we want, specify it as a new texture */
if(cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height){
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}else{
if(dirty){
/* otherwise, just subimage upload it so that drivers can tell we are going to be changing
* it and don't try and do a texture compression */
qglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data);
}
}
if(r_speeds->integer){
end = ri.Milliseconds();
ri.Printf(PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start);
}
/* FIXME: HUGE hack */
if(glRefConfig.framebufferObject && !glState.currentFBO){
if(backEnd.framePostProcessed){
FBO_Bind(tr.screenScratchFbo);
}else{
FBO_Bind(tr.renderFbo);
}
}
RB_SetGL2D();
tess.numIndexes = 0;
tess.numVertexes = 0;
tess.firstIndex = 0;
tess.xyz[tess.numVertexes][0] = x;
tess.xyz[tess.numVertexes][1] = y;
tess.xyz[tess.numVertexes][2] = 0;
tess.xyz[tess.numVertexes][3] = 1;
tess.texCoords[tess.numVertexes][0][0] = 0.5f / cols;
tess.texCoords[tess.numVertexes][0][1] = 0.5f / rows;
tess.texCoords[tess.numVertexes][0][2] = 0;
tess.texCoords[tess.numVertexes][0][3] = 1;
tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = x + w;
tess.xyz[tess.numVertexes][1] = y;
tess.xyz[tess.numVertexes][2] = 0;
tess.xyz[tess.numVertexes][3] = 1;
tess.texCoords[tess.numVertexes][0][0] = (cols - 0.5f) / cols;
tess.texCoords[tess.numVertexes][0][1] = 0.5f / rows;
tess.texCoords[tess.numVertexes][0][2] = 0;
tess.texCoords[tess.numVertexes][0][3] = 1;
tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = x + w;
tess.xyz[tess.numVertexes][1] = y + h;
tess.xyz[tess.numVertexes][2] = 0;
tess.xyz[tess.numVertexes][3] = 1;
tess.texCoords[tess.numVertexes][0][0] = (cols - 0.5f) / cols;
tess.texCoords[tess.numVertexes][0][1] = (rows - 0.5f) / rows;
tess.texCoords[tess.numVertexes][0][2] = 0;
tess.texCoords[tess.numVertexes][0][3] = 1;
tess.numVertexes++;
tess.xyz[tess.numVertexes][0] = x;
tess.xyz[tess.numVertexes][1] = y + h;
tess.xyz[tess.numVertexes][2] = 0;
tess.xyz[tess.numVertexes][3] = 1;
tess.texCoords[tess.numVertexes][0][0] = 0.5f / cols;
tess.texCoords[tess.numVertexes][0][1] = (rows - 0.5f) / rows;
tess.texCoords[tess.numVertexes][0][2] = 0;
tess.texCoords[tess.numVertexes][0][3] = 1;
tess.numVertexes++;
tess.indexes[tess.numIndexes++] = 0;
tess.indexes[tess.numIndexes++] = 1;
tess.indexes[tess.numIndexes++] = 2;
tess.indexes[tess.numIndexes++] = 0;
tess.indexes[tess.numIndexes++] = 2;
tess.indexes[tess.numIndexes++] = 3;
/* FIXME: A lot of this can probably be removed for speed, and refactored into a more convenient function */
RB_UpdateVBOs(ATTR_POSITION | ATTR_TEXCOORD);
sp = &tr.textureColorShader;
GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD);
GLSL_BindProgram(sp);
GLSL_SetUniformMatrix16(sp, TEXTURECOLOR_UNIFORM_MODELVIEWPROJECTIONMATRIX,
glState.modelviewProjection);
setv34(color, 1, 1, 1, 1);
GLSL_SetUniformVec4(sp, TEXTURECOLOR_UNIFORM_COLOR, color);
qglDrawElements(GL_TRIANGLES, tess.numIndexes, GL_INDEX_TYPE, BUFFER_OFFSET(0));
/* R_BindNullVBO();
* R_BindNullIBO(); */
tess.numIndexes = 0;
tess.numVertexes = 0;
tess.firstIndex = 0;
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
Used for cinematics.
=============
*/
void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) {
int i, j;
int start, end;
vec4_t quadVerts[4];
vec2_t texCoords[4];
if ( !tr.registered ) {
return;
}
R_IssuePendingRenderCommands();
if ( tess.numIndexes ) {
RB_EndSurface();
}
// we definately want to sync every frame for the cinematics
qglFinish();
start = 0;
if ( r_speeds->integer ) {
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0 ; ( 1 << i ) < cols ; i++ ) {
}
for ( j = 0 ; ( 1 << j ) < rows ; j++ ) {
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows) {
ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
}
RE_UploadCinematic (w, h, cols, rows, data, client, dirty);
if ( r_speeds->integer ) {
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
// FIXME: HUGE hack
if (glRefConfig.framebufferObject)
{
if (!tr.renderFbo || backEnd.framePostProcessed)
{
FBO_Bind(NULL);
}
else
{
FBO_Bind(tr.renderFbo);
}
}
RB_SetGL2D();
VectorSet4(quadVerts[0], x, y, 0.0f, 1.0f);
VectorSet4(quadVerts[1], x + w, y, 0.0f, 1.0f);
VectorSet4(quadVerts[2], x + w, y + h, 0.0f, 1.0f);
VectorSet4(quadVerts[3], x, y + h, 0.0f, 1.0f);
VectorSet2(texCoords[0], 0.5f / cols, 0.5f / rows);
VectorSet2(texCoords[1], (cols - 0.5f) / cols, 0.5f / rows);
VectorSet2(texCoords[2], (cols - 0.5f) / cols, (rows - 0.5f) / rows);
VectorSet2(texCoords[3], 0.5f / cols, (rows - 0.5f) / rows);
GLSL_BindProgram(&tr.textureColorShader);
GLSL_SetUniformMat4(&tr.textureColorShader, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniformVec4(&tr.textureColorShader, UNIFORM_COLOR, colorWhite);
RB_InstantQuad2(quadVerts, texCoords);
}
/*
* RB_SwapBuffers
*
*/
const void *
RB_SwapBuffers(const void *data)
{
const swapBuffersCommand_t *cmd;
/* finish any 2D drawing if needed */
if(tess.numIndexes){
RB_EndSurface();
}
/* texture swapping test */
if(r_showImages->integer){
RB_ShowImages();
}
cmd = (const swapBuffersCommand_t*)data;
/* we measure overdraw by reading back the stencil buffer and
* counting up the number of increments that have happened */
if(r_measureOverdraw->integer){
int i;
long sum = 0;
unsigned char *stencilReadback;
stencilReadback = ri.hunkalloctemp(glConfig.vidWidth * glConfig.vidHeight);
qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
stencilReadback);
for(i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++)
sum += stencilReadback[i];
backEnd.pc.c_overDraw += sum;
ri.hunkfreetemp(stencilReadback);
}
if(glRefConfig.framebufferObject){
/* copy final image to screen */
Vec2 texScale;
Vec4 srcBox, dstBox, white;
texScale[0] =
texScale[1] = 1.0f;
white[0] =
white[1] =
white[2] = pow(2, tr.overbrightBits); /* exp2(tr.overbrightBits); */
white[3] = 1.0f;
setv34(dstBox, 0, 0, glConfig.vidWidth, glConfig.vidHeight);
if(backEnd.framePostProcessed){
/* frame was postprocessed into screen fbo, copy from there */
setv34(srcBox, 0, 0, tr.screenScratchFbo->width, tr.screenScratchFbo->height);
FBO_Blit(tr.screenScratchFbo, srcBox, texScale, NULL, dstBox, &tr.textureColorShader,
white,
0);
}else{
/* frame still in render fbo, copy from there */
setv34(srcBox, 0, 0, tr.renderFbo->width, tr.renderFbo->height);
FBO_Blit(tr.renderFbo, srcBox, texScale, NULL, dstBox, &tr.textureColorShader, white,
0);
}
}
if(!glState.finishCalled){
qglFinish();
}
GLimp_LogComment("***************** RB_SwapBuffers *****************\n\n\n");
GLimp_EndFrame();
backEnd.framePostProcessed = qfalse;
backEnd.projection2D = qfalse;
return (const void*)(cmd + 1);
}
/*
==============
Z_Draw
==============
*/
void Z_Draw (void)
{
brush_t *brush;
float w, h;
double start, end;
qtexture_t *q;
float top, bottom;
vec3_t org_top, org_bottom, dir_up, dir_down;
int xCam = z.width/3;
if (!active_brushes.next)
return; // not valid yet
if (z.timing)
start = Sys_DoubleTime ();
//
// clear
//
qglViewport(0, 0, z.width, z.height);
qglClearColor (
g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][0],
g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][1],
g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][2],
0);
/* GL Bug */
/* When not using hw acceleration, gl will fault if we clear the depth
buffer bit on the first pass. The hack fix is to set the GL_DEPTH_BUFFER_BIT
only after Z_Draw() has been called once. Yeah, right. */
qglClear(glbitClear);
glbitClear |= GL_DEPTH_BUFFER_BIT;
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
w = z.width/2 / z.scale;
h = z.height/2 / z.scale;
qglOrtho (-w, w, z.origin[2]-h, z.origin[2]+h, -8, 8);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_TEXTURE_1D);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_BLEND);
//
// now draw the grid
//
Z_DrawGrid ();
//
// draw stuff
//
qglDisable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
qglDisable(GL_DEPTH_TEST);
// draw filled interiors and edges
dir_up[0] = 0 ; dir_up[1] = 0; dir_up[2] = 1;
dir_down[0] = 0 ; dir_down[1] = 0; dir_down[2] = -1;
VectorCopy (z.origin, org_top);
org_top[2] = MAX_WORLD_COORD;//4096; // MAX_WORLD_COORD ? (John said this didn't work, Hmmmmmm) // !suspect!
VectorCopy (z.origin, org_bottom);
org_bottom[2] = MIN_WORLD_COORD;//-4096; // MIN_WORLD_COORD? " " !suspect!
for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
{
if (brush->mins[0] >= z.origin[0]
|| brush->maxs[0] <= z.origin[0]
|| brush->mins[1] >= z.origin[1]
|| brush->maxs[1] <= z.origin[1])
continue;
if (!Brush_Ray (org_top, dir_down, brush, &top))
continue;
top = org_top[2] - top;
if (!Brush_Ray (org_bottom, dir_up, brush, &bottom))
continue;
bottom = org_bottom[2] + bottom;
q = Texture_ForName (brush->brush_faces->texdef.name);
qglColor3f (q->color[0], q->color[1], q->color[2]);
qglBegin (GL_QUADS);
qglVertex2f (-xCam, bottom);
qglVertex2f (xCam, bottom);
qglVertex2f (xCam, top);
qglVertex2f (-xCam, top);
qglEnd ();
qglColor3f (1,1,1);
qglBegin (GL_LINE_LOOP);
qglVertex2f (-xCam, bottom);
qglVertex2f (xCam, bottom);
qglVertex2f (xCam, top);
qglVertex2f (-xCam, top);
qglEnd ();
}
//
// now draw selected brushes
//
for (brush = selected_brushes.next ; brush != &selected_brushes ; brush=brush->next)
{
if ( !(brush->mins[0] >= z.origin[0]
|| brush->maxs[0] <= z.origin[0]
|| brush->mins[1] >= z.origin[1]
|| brush->maxs[1] <= z.origin[1]) )
{
if (Brush_Ray (org_top, dir_down, brush, &top))
{
top = org_top[2] - top;
if (Brush_Ray (org_bottom, dir_up, brush, &bottom))
{
bottom = org_bottom[2] + bottom;
q = Texture_ForName (brush->brush_faces->texdef.name);
qglColor3f (q->color[0], q->color[1], q->color[2]);
qglBegin (GL_QUADS);
qglVertex2f (-xCam, bottom);
qglVertex2f (xCam, bottom);
qglVertex2f (xCam, top);
qglVertex2f (-xCam, top);
qglEnd ();
}
}
}
qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES]);
qglBegin (GL_LINE_LOOP);
qglVertex2f (-xCam, brush->mins[2]);
qglVertex2f (xCam, brush->mins[2]);
qglVertex2f (xCam, brush->maxs[2]);
qglVertex2f (-xCam, brush->maxs[2]);
qglEnd ();
}
ZDrawCameraIcon ();
ZDrawZClip();
qglFinish();
QE_CheckOpenGLForErrors();
if (z.timing)
{
end = Sys_DoubleTime ();
Sys_Printf ("z: %i ms\n", (int)(1000*(end-start)));
}
}
/*
===============
RB_ShowImages
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
Also called by RE_EndRegistration
===============
*/
void RB_ShowImages( void ) {
int i;
image_t *image;
float x, y, w, h;
int start, end;
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
start = ri.Milliseconds();
for ( i = 0 ; i < tr.numImages ; i++ ) {
image = tr.images[i];
w = glConfig.vidWidth / 40;
h = glConfig.vidHeight / 30;
x = i % 40 * w;
y = i / 30 * h;
// show in proportional size in mode 2
if ( r_showImages->integer == 2 ) {
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
#ifdef USE_OPENGLES
GLfloat tex[] = {
0, 0,
1, 0,
1, 1,
0, 1 };
GLfloat vtx[] = {
x, y,
x + w, y,
x + w, y + h,
x, y + h };
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
qglDisableClientState(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 2, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (glcol)
qglEnableClientState(GL_COLOR_ARRAY);
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#else
GL_Bind( image );
qglBegin( GL_QUADS );
qglTexCoord2f( 0, 0 );
qglVertex2f( x, y );
qglTexCoord2f( 1, 0 );
qglVertex2f( x + w, y );
qglTexCoord2f( 1, 1 );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0, 1 );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
/*
=============
RB_SwapBuffers
=============
*/
const void *RB_SwapBuffers( const void *data )
{
const swapBuffersCommand_t *cmd;
// finish any 2D drawing if needed
if ( tess.numIndexes )
{
Tess_End();
}
// texture swapping test
#if !defined( USE_D3D10 )
if ( r_showImages->integer )
{
RB_ShowImages();
}
#endif
cmd = ( const swapBuffersCommand_t * ) data;
#if defined( USE_D3D10 )
// TODO
#else
// we measure overdraw by reading back the stencil buffer and
// counting up the number of increments that have happened
if ( r_measureOverdraw->integer )
{
int i;
long sum = 0;
unsigned char *stencilReadback;
stencilReadback = ri.Hunk_AllocateTempMemory( glConfig.vidWidth * glConfig.vidHeight );
qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencilReadback );
for ( i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++ )
{
sum += stencilReadback[ i ];
}
backEnd.pc.c_overDraw += sum;
ri.Hunk_FreeTempMemory( stencilReadback );
}
#endif
#if defined( USE_D3D10 )
// TODO
#else
if ( !glState.finishCalled )
{
qglFinish();
}
#endif
GLimp_LogComment( "***************** RB_SwapBuffers *****************\n\n\n" );
// present the information rendered to the back buffer to the front buffer (the screen)
dx.swapChain->Present( 0, 0 );
if ( r_fullscreen->modified )
{
bool fullscreen;
bool needToToggle = qtrue;
bool sdlToggled = qfalse;
SDL_Surface *s = SDL_GetVideoSurface();
if ( s )
{
// Find out the current state
fullscreen = !!( s->flags & SDL_FULLSCREEN );
if ( r_fullscreen->integer > 0 && ri.Cvar_VariableIntegerValue( "in_nograb" ) > 0 )
{
ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n" );
ri.Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = qfalse;
}
// Is the state we want different from the current state?
needToToggle = !!r_fullscreen->integer != fullscreen;
if ( needToToggle )
{
sdlToggled = SDL_WM_ToggleFullScreen( s );
}
}
if ( needToToggle )
{
// SDL_WM_ToggleFullScreen didn't work, so do it the slow way
if ( !sdlToggled )
{
ri.Cmd_ExecuteText( EXEC_APPEND, "vid_restart" );
}
ri.IN_Restart();
}
r_fullscreen->modified = qfalse;
}
backEnd.projection2D = qfalse;
return ( const void * )( cmd + 1 );
}
void RB_ShowImages( void )
{
int i;
image_t *image;
float x, y, w, h;
vec4_t quadVerts[ 4 ];
int start, end;
GLimp_LogComment( "--- RB_ShowImages ---\n" );
if ( !backEnd.projection2D )
{
RB_SetGL2D();
}
qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
GL_BindProgram( &tr.genericSingleShader );
GL_Cull( CT_TWO_SIDED );
// set uniforms
GLSL_SetUniform_TCGen_Environment( &tr.genericSingleShader, qfalse );
GLSL_SetUniform_ColorGen( &tr.genericSingleShader, CGEN_VERTEX );
GLSL_SetUniform_AlphaGen( &tr.genericSingleShader, AGEN_VERTEX );
if ( glConfig.vboVertexSkinningAvailable )
{
GLSL_SetUniform_VertexSkinning( &tr.genericSingleShader, qfalse );
}
GLSL_SetUniform_DeformGen( &tr.genericSingleShader, DGEN_NONE );
GLSL_SetUniform_AlphaTest( &tr.genericSingleShader, 0 );
GLSL_SetUniform_ColorTextureMatrix( &tr.genericSingleShader, matrixIdentity );
GL_SelectTexture( 0 );
start = ri.Milliseconds();
for ( i = 0; i < tr.images.currentElements; i++ )
{
image = Com_GrowListElement( &tr.images, i );
/*
if(image->bits & (IF_RGBA16F | IF_RGBA32F | IF_LA16F | IF_LA32F))
{
// don't render float textures using FFP
continue;
}
*/
w = glConfig.vidWidth / 20;
h = glConfig.vidHeight / 15;
x = i % 20 * w;
y = i / 20 * h;
// show in proportional size in mode 2
if ( r_showImages->integer == 2 )
{
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
// bind u_ColorMap
GL_Bind( image );
VectorSet4( quadVerts[ 0 ], x, y, 0, 1 );
VectorSet4( quadVerts[ 1 ], x + w, y, 0, 1 );
VectorSet4( quadVerts[ 2 ], x + w, y + h, 0, 1 );
VectorSet4( quadVerts[ 3 ], x, y + h, 0, 1 );
Tess_InstantQuad( quadVerts );
/*
qglBegin(GL_QUADS);
qglVertexAttrib4fARB(ATTR_INDEX_TEXCOORD0, 0, 0, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_POSITION, x, y, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_TEXCOORD0, 1, 0, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_POSITION, x + w, y, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_TEXCOORD0, 1, 1, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_POSITION, x + w, y + h, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_TEXCOORD0, 0, 1, 0, 1);
qglVertexAttrib4fARB(ATTR_INDEX_POSITION, x, y + h, 0, 1);
qglEnd();
*/
}
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
GL_CheckErrors();
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
Used for cinematics.
=============
*/
void RE_StretchRaw( int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty ) {
int i, j;
int start, end;
if ( !tr.registered ) {
return;
}
R_IssuePendingRenderCommands();
if ( tess.numIndexes ) {
RB_EndSurface();
}
// we definately want to sync every frame for the cinematics
qglFinish();
start = 0;
if ( r_speeds->integer ) {
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0 ; ( 1 << i ) < cols ; i++ ) {
}
for ( j = 0 ; ( 1 << j ) < rows ; j++ ) {
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows ) {
ri.Error( ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows );
}
GL_Bind( tr.scratchImage[client] );
// if the scratchImage isn't in the format we want, specify it as a new texture
if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
#ifdef USE_OPENGLES
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#else
qglTexImage2D( GL_TEXTURE_2D, 0, 3, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#endif
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
} else {
if ( dirty ) {
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
// it and don't try and do a texture compression
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
}
}
if ( r_speeds->integer ) {
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
RB_SetGL2D();
qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
#ifdef USE_OPENGLES
GLfloat tex[] = {
0.5f / cols, 0.5f / rows,
( cols - 0.5f ) / cols , 0.5f / rows,
( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows,
0.5f / cols, ( rows - 0.5f ) / rows };
GLfloat vtx[] = {
x, y,
x+w, y,
x+w, y+h,
x, y+h };
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
qglDisableClientState(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 2, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglEnableClientState(GL_COLOR_ARRAY);
#else
qglBegin( GL_QUADS );
qglTexCoord2f( 0.5f / cols, 0.5f / rows );
qglVertex2f( x, y );
qglTexCoord2f( ( cols - 0.5f ) / cols, 0.5f / rows );
qglVertex2f( x + w, y );
qglTexCoord2f( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0.5f / cols, ( rows - 0.5f ) / rows );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
Used for cinematics.
=============
*/
void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) {
int i, j;
int start, end;
#ifdef VCMODS_OPENGLES
vec2_t texcoords[4];
vec2_t verts[4];
glIndex_t indicies[6] = {0, 1, 2, 0, 3, 2};
#endif
if ( !tr.registered ) {
return;
}
R_SyncRenderThread();
// we definately want to sync every frame for the cinematics
qglFinish();
start = end = 0;
if ( r_speeds->integer ) {
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0 ; ( 1 << i ) < cols ; i++ ) {
}
for ( j = 0 ; ( 1 << j ) < rows ; j++ ) {
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows) {
ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
}
GL_Bind( tr.scratchImage[client] );
// if the scratchImage isn't in the format we want, specify it as a new texture
if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
#ifdef VCMODS_OPENGLES
//don't do qglTexImage2D as this may end up doing a compressed image
//on which we are not allowed to do further sub images
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#else
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#endif
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
} else {
if (dirty) {
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
// it and don't try and do a texture compression
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
}
}
if ( r_speeds->integer ) {
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
RB_SetGL2D();
#ifdef VCMODS_OPENGLES
qglColor4f( tr.identityLight, tr.identityLight, tr.identityLight, 1.0f );
verts[0][0] = x; verts[0][1] = y;
verts[1][0] = x+w; verts[1][1] = y;
verts[2][0] = x+w; verts[2][1] = y+h;
verts[3][0] = x; verts[3][1] = y+h;
texcoords[0][0] = 0.5f/cols; texcoords[0][1] = 0.5f/rows;
texcoords[1][0] = (cols-0.5f)/cols; texcoords[1][1] = 0.5f/rows;
texcoords[2][0] = (cols-0.5f)/cols; texcoords[2][1] = (rows-0.5f)/rows;
texcoords[3][0] = 0.5f/cols; texcoords[3][1] = (rows-0.5f)/rows;
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, texcoords );
qglVertexPointer ( 2, GL_FLOAT, 0, verts );
qglDrawElements( GL_TRIANGLE_STRIP, 6, GL_INDEX_TYPE, indicies );
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#else
qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
qglBegin (GL_QUADS);
qglTexCoord2f ( 0.5f / cols, 0.5f / rows );
qglVertex2f (x, y);
qglTexCoord2f ( ( cols - 0.5f ) / cols , 0.5f / rows );
qglVertex2f (x+w, y);
qglTexCoord2f ( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows );
qglVertex2f (x+w, y+h);
qglTexCoord2f ( 0.5f / cols, ( rows - 0.5f ) / rows );
qglVertex2f (x, y+h);
qglEnd ();
#endif
}
/*
===============
RB_ShowImages
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
Also called by RE_EndRegistration
===============
*/
void RB_ShowImages( void ) {
int i;
image_t *image;
float x, y, w, h;
int start, end;
#ifdef VCMODS_OPENGLES
vec2_t texcoords[4] = { {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f} };
vec2_t verts[4];
glIndex_t indicies[6] = { 0, 1, 2, 0, 3, 2};
#endif
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
start = ri.Milliseconds();
#ifdef VCMODS_OPENGLES
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
for ( i=0 ; i<tr.numImages ; i++ ) {
image = tr.images[i];
w = glConfig.vidWidth / 20;
h = glConfig.vidHeight / 15;
x = i % 20 * w;
y = i / 20 * h;
// show in proportional size in mode 2
if ( r_showImages->integer == 2 ) {
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
#ifdef VCMODS_OPENGLES
verts[0][0] = x; verts[0][1] = y;
verts[1][0] = x+w; verts[1][1] = y;
verts[2][0] = x+w; verts[2][1] = y+h;
verts[3][0] = x; verts[3][1] = y+h;
qglTexCoordPointer( 2, GL_FLOAT, 0, texcoords );
qglVertexPointer ( 2, GL_FLOAT, 0, verts );
qglDrawElements( GL_TRIANGLE_STRIP, 6, GL_INDEX_TYPE, indicies );
#else
GL_Bind( image );
qglBegin (GL_QUADS);
qglTexCoord2f( 0, 0 );
qglVertex2f( x, y );
qglTexCoord2f( 1, 0 );
qglVertex2f( x + w, y );
qglTexCoord2f( 1, 1 );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0, 1 );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
#ifdef VCMODS_OPENGLES
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
static void RB_BeginDrawingView (void) {
int clearBits = GL_DEPTH_BUFFER_BIT;
// sync with gl if needed
if ( r_finish->integer == 1 && !glState.finishCalled ) {
qglFinish ();
glState.finishCalled = qtrue;
}
if ( r_finish->integer == 0 ) {
glState.finishCalled = qtrue;
}
// we will need to change the projection matrix before drawing
// 2D images again
backEnd.projection2D = qfalse;
//
// set the modelview matrix for the viewer
//
SetViewportAndScissor();
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// clear relevant buffers
if ( r_measureOverdraw->integer || r_shadows->integer == 2 || tr_stencilled )
{
clearBits |= GL_STENCIL_BUFFER_BIT;
tr_stencilled = false;
}
if (skyboxportal)
{
if ( backEnd.refdef.rdflags & RDF_SKYBOXPORTAL )
{ // portal scene, clear whatever is necessary
if (r_fastsky->integer || (backEnd.refdef.rdflags & RDF_NOWORLDMODEL) )
{ // fastsky: clear color
// try clearing first with the portal sky fog color, then the world fog color, then finally a default
clearBits |= GL_COLOR_BUFFER_BIT;
if (tr.world && tr.world->globalFog != -1)
{
const fog_t *fog = &tr.world->fogs[tr.world->globalFog];
qglClearColor(fog->parms.color[0], fog->parms.color[1], fog->parms.color[2], 1.0f );
}
else
{
qglClearColor ( 0.3f, 0.3f, 0.3f, 1.0 );
}
}
}
}
else
{
if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && !g_bRenderGlowingObjects )
{
if (tr.world && tr.world->globalFog != -1)
{
const fog_t *fog = &tr.world->fogs[tr.world->globalFog];
qglClearColor(fog->parms.color[0], fog->parms.color[1], fog->parms.color[2], 1.0f );
}
else
{
qglClearColor( 0.3f, 0.3f, 0.3f, 1 ); // FIXME: get color of sky
}
clearBits |= GL_COLOR_BUFFER_BIT; // FIXME: only if sky shaders have been used
}
}
if ( !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && ( r_DynamicGlow->integer && !g_bRenderGlowingObjects ) )
{
if (tr.world && tr.world->globalFog != -1)
{ //this is because of a bug in multiple scenes I think, it needs to clear for the second scene but it doesn't normally.
const fog_t *fog = &tr.world->fogs[tr.world->globalFog];
qglClearColor(fog->parms.color[0], fog->parms.color[1], fog->parms.color[2], 1.0f );
clearBits |= GL_COLOR_BUFFER_BIT;
}
}
// If this pass is to just render the glowing objects, don't clear the depth buffer since
// we're sharing it with the main scene (since the main scene has already been rendered). -AReis
if ( g_bRenderGlowingObjects )
{
clearBits &= ~GL_DEPTH_BUFFER_BIT;
}
if (clearBits)
{
qglClear( clearBits );
}
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
{
RB_Hyperspace();
return;
}
else
{
backEnd.isHyperspace = qfalse;
}
glState.faceCulling = -1; // force face culling to set next time
// we will only draw a sun if there was sky rendered in this view
backEnd.skyRenderedThisView = qfalse;
// clip to the plane of the portal
if ( backEnd.viewParms.isPortal ) {
float plane[4];
double plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct (backEnd.viewParms.ori.axis[0], plane);
plane2[1] = DotProduct (backEnd.viewParms.ori.axis[1], plane);
plane2[2] = DotProduct (backEnd.viewParms.ori.axis[2], plane);
plane2[3] = DotProduct (plane, backEnd.viewParms.ori.origin) - plane[3];
qglLoadMatrixf( s_flipMatrix );
qglClipPlane (GL_CLIP_PLANE0, plane2);
qglEnable (GL_CLIP_PLANE0);
} else {
qglDisable (GL_CLIP_PLANE0);
}
}
/*
=============
RB_DrawSurfs
=============
*/
const void *RB_DrawSurfs( const void *data ) {
const drawSurfsCommand_t *cmd;
// finish any 2D drawing if needed
if ( tess.numIndexes ) {
RB_EndSurface();
}
cmd = (const drawSurfsCommand_t *)data;
backEnd.refdef = cmd->refdef;
backEnd.viewParms = cmd->viewParms;
RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
// Dynamic Glow/Flares:
/*
The basic idea is to render the glowing parts of the scene to an offscreen buffer, then take
that buffer and blur it. After it is sufficiently blurred, re-apply that image back to
the normal screen using a additive blending. To blur the scene I use a vertex program to supply
four texture coordinate offsets that allow 'peeking' into adjacent pixels. In the register
combiner (pixel shader), I combine the adjacent pixels using a weighting factor. - Aurelio
*/
// Render dynamic glowing/flaring objects.
if ( !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL) && g_bDynamicGlowSupported && r_DynamicGlow->integer )
{
// Copy the normal scene to texture.
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight);
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
// Just clear colors, but leave the depth buffer intact so we can 'share' it.
qglClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
qglClear( GL_COLOR_BUFFER_BIT );
// Render the glowing objects.
g_bRenderGlowingObjects = true;
RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
g_bRenderGlowingObjects = false;
qglFinish();
// Copy the glow scene to texture.
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
// Resize the viewport to the blur texture size.
const int oldViewWidth = backEnd.viewParms.viewportWidth;
const int oldViewHeight = backEnd.viewParms.viewportHeight;
backEnd.viewParms.viewportWidth = r_DynamicGlowWidth->integer;
backEnd.viewParms.viewportHeight = r_DynamicGlowHeight->integer;
SetViewportAndScissor();
// Blur the scene.
RB_BlurGlowTexture();
// Copy the finished glow scene back to texture.
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
// Set the viewport back to normal.
backEnd.viewParms.viewportWidth = oldViewWidth;
backEnd.viewParms.viewportHeight = oldViewHeight;
SetViewportAndScissor();
qglClear( GL_COLOR_BUFFER_BIT );
// Draw the glow additively over the screen.
RB_DrawGlowOverlay();
}
return (const void *)(cmd + 1);
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
Used for cinematics.
=============
*/
void RE_StretchRaw( int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty )
{
int i, j;
int start, end;
if ( !tr.registered )
{
return;
}
R_SyncRenderThread();
// we definitely want to sync every frame for the cinematics
#if defined( USE_D3D10 )
// TODO
#else
qglFinish();
#endif
start = end = 0;
if ( r_speeds->integer )
{
#if defined( USE_D3D10 )
// TODO
#else
qglFinish();
#endif
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0; ( 1 << i ) < cols; i++ )
{
}
for ( j = 0; ( 1 << j ) < rows; j++ )
{
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows )
{
ri.Error( ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows );
}
#if defined( USE_D3D10 )
// TODO
#else
RB_SetGL2D();
qglVertexAttrib4fARB( ATTR_INDEX_NORMAL, 0, 0, 1, 1 );
qglVertexAttrib4fARB( ATTR_INDEX_COLOR, tr.identityLight, tr.identityLight, tr.identityLight, 1 );
GL_BindProgram( &tr.genericSingleShader );
// set uniforms
GLSL_SetUniform_TCGen_Environment( &tr.genericSingleShader, qfalse );
GLSL_SetUniform_ColorGen( &tr.genericSingleShader, CGEN_VERTEX );
GLSL_SetUniform_AlphaGen( &tr.genericSingleShader, AGEN_VERTEX );
//GLSL_SetUniform_Color(&tr.genericSingleShader, colorWhite);
if ( glConfig.vboVertexSkinningAvailable )
{
GLSL_SetUniform_VertexSkinning( &tr.genericSingleShader, qfalse );
}
GLSL_SetUniform_DeformGen( &tr.genericSingleShader, DGEN_NONE );
GLSL_SetUniform_AlphaTest( &tr.genericSingleShader, 0 );
GLSL_SetUniform_ModelViewProjectionMatrix( &tr.genericSingleShader, glState.modelViewProjectionMatrix[ glState.stackIndex ] );
// bind u_ColorMap
GL_SelectTexture( 0 );
GL_Bind( tr.scratchImage[ client ] );
GLSL_SetUniform_ColorTextureMatrix( &tr.genericSingleShader, matrixIdentity );
// if the scratchImage isn't in the format we want, specify it as a new texture
if ( cols != tr.scratchImage[ client ]->width || rows != tr.scratchImage[ client ]->height )
{
tr.scratchImage[ client ]->width = tr.scratchImage[ client ]->uploadWidth = cols;
tr.scratchImage[ client ]->height = tr.scratchImage[ client ]->uploadHeight = rows;
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
}
else
{
if ( dirty )
{
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
// it and don't try and do a texture compression
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
}
}
#endif // #if defined(USE_D3D10)
if ( r_speeds->integer )
{
#if defined( USE_D3D10 )
// TODO
#else
qglFinish();
#endif
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
tess.numVertexes = 0;
tess.numIndexes = 0;
tess.xyz[ tess.numVertexes ][ 0 ] = x;
tess.xyz[ tess.numVertexes ][ 1 ] = y;
tess.xyz[ tess.numVertexes ][ 2 ] = 0;
tess.xyz[ tess.numVertexes ][ 3 ] = 1;
tess.texCoords[ tess.numVertexes ][ 0 ] = 0.5f / cols;
tess.texCoords[ tess.numVertexes ][ 1 ] = 0.5f / rows;
tess.texCoords[ tess.numVertexes ][ 2 ] = 0;
tess.texCoords[ tess.numVertexes ][ 3 ] = 1;
tess.numVertexes++;
tess.xyz[ tess.numVertexes ][ 0 ] = x + w;
tess.xyz[ tess.numVertexes ][ 1 ] = y;
tess.xyz[ tess.numVertexes ][ 2 ] = 0;
tess.xyz[ tess.numVertexes ][ 3 ] = 1;
tess.texCoords[ tess.numVertexes ][ 0 ] = ( cols - 0.5f ) / cols;
tess.texCoords[ tess.numVertexes ][ 1 ] = 0.5f / rows;
tess.texCoords[ tess.numVertexes ][ 2 ] = 0;
tess.texCoords[ tess.numVertexes ][ 3 ] = 1;
tess.numVertexes++;
tess.xyz[ tess.numVertexes ][ 0 ] = x + w;
tess.xyz[ tess.numVertexes ][ 1 ] = y + h;
tess.xyz[ tess.numVertexes ][ 2 ] = 0;
tess.xyz[ tess.numVertexes ][ 3 ] = 1;
tess.texCoords[ tess.numVertexes ][ 0 ] = ( cols - 0.5f ) / cols;
tess.texCoords[ tess.numVertexes ][ 1 ] = ( rows - 0.5f ) / rows;
tess.texCoords[ tess.numVertexes ][ 2 ] = 0;
tess.texCoords[ tess.numVertexes ][ 3 ] = 1;
tess.numVertexes++;
tess.xyz[ tess.numVertexes ][ 0 ] = x;
tess.xyz[ tess.numVertexes ][ 1 ] = y + h;
tess.xyz[ tess.numVertexes ][ 2 ] = 0;
tess.xyz[ tess.numVertexes ][ 3 ] = 1;
tess.texCoords[ tess.numVertexes ][ 0 ] = 0.5f / cols;
tess.texCoords[ tess.numVertexes ][ 1 ] = ( rows - 0.5f ) / rows;
tess.texCoords[ tess.numVertexes ][ 2 ] = 0;
tess.texCoords[ tess.numVertexes ][ 3 ] = 1;
tess.numVertexes++;
tess.indexes[ tess.numIndexes++ ] = 0;
tess.indexes[ tess.numIndexes++ ] = 1;
tess.indexes[ tess.numIndexes++ ] = 2;
tess.indexes[ tess.numIndexes++ ] = 0;
tess.indexes[ tess.numIndexes++ ] = 2;
tess.indexes[ tess.numIndexes++ ] = 3;
Tess_UpdateVBOs( ATTR_POSITION | ATTR_TEXCOORD );
Tess_DrawElements();
tess.numVertexes = 0;
tess.numIndexes = 0;
#if defined( USE_D3D10 )
// TODO
#else
GL_CheckErrors();
#endif
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
void RB_BeginDrawingView (void) {
int clearBits = 0;
// sync with gl if needed
if ( r_finish->integer == 1 && !glState.finishCalled ) {
qglFinish ();
glState.finishCalled = qtrue;
}
if ( r_finish->integer == 0 ) {
glState.finishCalled = qtrue;
}
// we will need to change the projection matrix before drawing
// 2D images again
backEnd.projection2D = qfalse;
//
// set the modelview matrix for the viewer
//
SetViewportAndScissor();
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// clear relevant buffers
clearBits = GL_DEPTH_BUFFER_BIT;
if ( r_measureOverdraw->integer || r_shadows->integer == 2 )
{
clearBits |= GL_STENCIL_BUFFER_BIT;
}
if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) )
{
clearBits |= GL_COLOR_BUFFER_BIT; // FIXME: only if sky shaders have been used
#ifdef _DEBUG
qglClearColor( 0.8f, 0.7f, 0.4f, 1.0f ); // FIXME: get color of sky
#else
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // FIXME: get color of sky
#endif
}
qglClear( clearBits );
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
{
RB_Hyperspace();
return;
}
else
{
backEnd.isHyperspace = qfalse;
}
glState.faceCulling = -1; // force face culling to set next time
// we will only draw a sun if there was sky rendered in this view
backEnd.skyRenderedThisView = qfalse;
// clip to the plane of the portal
if ( backEnd.viewParms.isPortal ) {
float plane[4];
double plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane);
plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane);
plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane);
plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3];
qglLoadMatrixf( s_flipMatrix );
qglClipPlane (GL_CLIP_PLANE0, plane2);
qglEnable (GL_CLIP_PLANE0);
} else {
qglDisable (GL_CLIP_PLANE0);
}
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
void RB_BeginDrawingView( void ) {
int clearBits = 0;
// sync with gl if needed
if ( r_finish->integer == 1 && !glState.finishCalled ) {
qglFinish();
glState.finishCalled = qtrue;
}
if ( r_finish->integer == 0 ) {
glState.finishCalled = qtrue;
}
// we will need to change the projection matrix before drawing
// 2D images again
backEnd.projection2D = qfalse;
//
// set the modelview matrix for the viewer
//
SetViewportAndScissor();
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
////////// (SA) modified to ensure one glclear() per frame at most
// clear relevant buffers
clearBits = 0;
if ( r_measureOverdraw->integer || r_shadows->integer == 2 ) {
clearBits |= GL_STENCIL_BUFFER_BIT;
}
if ( r_uiFullScreen->integer ) {
clearBits = GL_DEPTH_BUFFER_BIT; // (SA) always just clear depth for menus
} else if ( skyboxportal ) {
if ( backEnd.refdef.rdflags & RDF_SKYBOXPORTAL ) { // portal scene, clear whatever is necessary
clearBits |= GL_DEPTH_BUFFER_BIT;
if ( r_fastsky->integer || backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) { // fastsky: clear color
// try clearing first with the portal sky fog color, then the world fog color, then finally a default
clearBits |= GL_COLOR_BUFFER_BIT;
if ( glfogsettings[FOG_PORTALVIEW].registered ) {
qglClearColor( glfogsettings[FOG_PORTALVIEW].color[0], glfogsettings[FOG_PORTALVIEW].color[1], glfogsettings[FOG_PORTALVIEW].color[2], glfogsettings[FOG_PORTALVIEW].color[3] );
} else if ( glfogNum > FOG_NONE && glfogsettings[FOG_CURRENT].registered ) {
qglClearColor( glfogsettings[FOG_CURRENT].color[0], glfogsettings[FOG_CURRENT].color[1], glfogsettings[FOG_CURRENT].color[2], glfogsettings[FOG_CURRENT].color[3] );
} else {
// qglClearColor ( 1.0, 0.0, 0.0, 1.0 ); // red clear for testing portal sky clear
qglClearColor( 0.5, 0.5, 0.5, 1.0 );
}
} else { // rendered sky (either clear color or draw quake sky)
if ( glfogsettings[FOG_PORTALVIEW].registered ) {
qglClearColor( glfogsettings[FOG_PORTALVIEW].color[0], glfogsettings[FOG_PORTALVIEW].color[1], glfogsettings[FOG_PORTALVIEW].color[2], glfogsettings[FOG_PORTALVIEW].color[3] );
if ( glfogsettings[FOG_PORTALVIEW].clearscreen ) { // portal fog requests a screen clear (distance fog rather than quake sky)
clearBits |= GL_COLOR_BUFFER_BIT;
}
}
}
} else { // world scene with portal sky, don't clear any buffers, just set the fog color if there is one
clearBits |= GL_DEPTH_BUFFER_BIT; // this will go when I get the portal sky rendering way out in the zbuffer (or not writing to zbuffer at all)
if ( glfogNum > FOG_NONE && glfogsettings[FOG_CURRENT].registered ) {
if ( backEnd.refdef.rdflags & RDF_UNDERWATER ) {
if ( glfogsettings[FOG_CURRENT].mode == GL_LINEAR ) {
clearBits |= GL_COLOR_BUFFER_BIT;
}
} else if ( !( r_portalsky->integer ) ) { // portal skies have been manually turned off, clear bg color
clearBits |= GL_COLOR_BUFFER_BIT;
}
qglClearColor( glfogsettings[FOG_CURRENT].color[0], glfogsettings[FOG_CURRENT].color[1], glfogsettings[FOG_CURRENT].color[2], glfogsettings[FOG_CURRENT].color[3] );
}
}
} else { // world scene with no portal sky
clearBits |= GL_DEPTH_BUFFER_BIT;
// NERVE - SMF - we don't want to clear the buffer when no world model is specified
if ( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) {
clearBits &= ~GL_COLOR_BUFFER_BIT;
}
// -NERVE - SMF
// (SA) well, this is silly then
else if ( r_fastsky->integer ) { // || backEnd.refdef.rdflags & RDF_NOWORLDMODEL
clearBits |= GL_COLOR_BUFFER_BIT;
if ( glfogsettings[FOG_CURRENT].registered ) { // try to clear fastsky with current fog color
qglClearColor( glfogsettings[FOG_CURRENT].color[0], glfogsettings[FOG_CURRENT].color[1], glfogsettings[FOG_CURRENT].color[2], glfogsettings[FOG_CURRENT].color[3] );
} else {
// qglClearColor ( 0.0, 0.0, 1.0, 1.0 ); // blue clear for testing world sky clear
qglClearColor( 0.5, 0.5, 0.5, 1.0 );
}
} else { // world scene, no portal sky, not fastsky, clear color if fog says to, otherwise, just set the clearcolor
if ( glfogsettings[FOG_CURRENT].registered ) { // try to clear fastsky with current fog color
qglClearColor( glfogsettings[FOG_CURRENT].color[0], glfogsettings[FOG_CURRENT].color[1], glfogsettings[FOG_CURRENT].color[2], glfogsettings[FOG_CURRENT].color[3] );
if ( glfogsettings[FOG_CURRENT].clearscreen ) { // world fog requests a screen clear (distance fog rather than quake sky)
clearBits |= GL_COLOR_BUFFER_BIT;
}
}
}
}
if ( clearBits ) {
qglClear( clearBits );
}
//----(SA) done
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) ) {
RB_Hyperspace();
return;
} else
{
backEnd.isHyperspace = qfalse;
}
glState.faceCulling = -1; // force face culling to set next time
// we will only draw a sun if there was sky rendered in this view
backEnd.skyRenderedThisView = qfalse;
// clip to the plane of the portal
if ( backEnd.viewParms.isPortal ) {
float plane[4];
double plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct( backEnd.viewParms.or.axis[0], plane );
plane2[1] = DotProduct( backEnd.viewParms.or.axis[1], plane );
plane2[2] = DotProduct( backEnd.viewParms.or.axis[2], plane );
plane2[3] = DotProduct( plane, backEnd.viewParms.or.origin ) - plane[3];
qglLoadMatrixf( s_flipMatrix );
qglClipPlane( GL_CLIP_PLANE0, plane2 );
qglEnable( GL_CLIP_PLANE0 );
} else {
qglDisable( GL_CLIP_PLANE0 );
}
}
void CCamWnd::Cam_Draw()
{
brush_t *brush;
face_t *face;
float screenaspect;
float yfov;
double start, end;
int i;
/*
FILE *f = fopen("g:/nardo/raduffy/editorhack.dat", "w");
if (f != NULL) {
fwrite(&m_Camera.origin[0], sizeof(float), 1, f);
fwrite(&m_Camera.origin[1], sizeof(float), 1, f);
fwrite(&m_Camera.origin[2], sizeof(float), 1, f);
fwrite(&m_Camera.angles[PITCH], sizeof(float), 1, f);
fwrite(&m_Camera.angles[YAW], sizeof(float), 1, f);
fclose(f);
}
*/
if (!active_brushes.next)
return; // not valid yet
if (m_Camera.timing)
start = Sys_DoubleTime ();
//
// clear
//
QE_CheckOpenGLForErrors();
qglViewport(0, 0, m_Camera.width, m_Camera.height);
qglScissor(0, 0, m_Camera.width, m_Camera.height);
qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],
g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],
g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// set up viewpoint
//
vec5_t lightPos;
if (g_PrefsDlg.m_bGLLighting)
{
qglEnable(GL_LIGHTING);
//qglEnable(GL_LIGHT0);
lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
lightPos[3] = 1.0;
qglLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightPos);
//qglLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
//lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
//qglLightfv(GL_LIGHT0, GL_AMBIENT, lightPos);
}
else
{
qglDisable(GL_LIGHTING);
}
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
screenaspect = (float)m_Camera.width / m_Camera.height;
yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;
qgluPerspective (yfov, screenaspect, 2, 8192);
qglRotatef (-90, 1, 0, 0); // put Z going up
qglRotatef (90, 0, 0, 1); // put Z going up
qglRotatef (m_Camera.angles[0], 0, 1, 0);
qglRotatef (-m_Camera.angles[1], 0, 0, 1);
qglTranslatef (-m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
Cam_BuildMatrix ();
//if (m_Camera.draw_mode == cd_light)
//{
// if (g_PrefsDlg.m_bGLLighting)
// {
// VectorCopy(m_Camera.origin, lightPos);
// lightPos[3] = 1;
// qglLightfv(GL_LIGHT0, GL_POSITION, lightPos);
// }
//}
InitCull ();
//
// draw stuff
//
GLfloat lAmbient[] = {1.0, 1.0, 1.0, 1.0};
switch (m_Camera.draw_mode)
{
case cd_wire:
qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_TEXTURE_1D);
qglDisable(GL_BLEND);
qglDisable(GL_DEPTH_TEST);
qglColor3f(1.0, 1.0, 1.0);
// qglEnable (GL_LINE_SMOOTH);
break;
case cd_solid:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
qglEnable(GL_DEPTH_TEST);
qglDepthFunc (GL_LEQUAL);
break;
case cd_texture:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglEnable(GL_TEXTURE_2D);
qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglDisable(GL_BLEND);
qglEnable(GL_DEPTH_TEST);
qglDepthFunc (GL_LEQUAL);
break;
case cd_blend:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglEnable(GL_TEXTURE_2D);
qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglDisable(GL_DEPTH_TEST);
qglEnable (GL_BLEND);
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
}
qglMatrixMode(GL_TEXTURE);
m_nNumTransBrushes = 0;
for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
{
//DrawLightRadius(brush);
if (CullBrush (brush))
continue;
if (FilterBrush (brush))
continue;
if ((brush->brush_faces->texdef.flags & (SURF_TRANS33 | SURF_TRANS66)) || (brush->brush_faces->d_texture->bFromShader && brush->brush_faces->d_texture->fTrans != 1.0))
{
m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
}
else
{
//-- if (brush->patchBrush)
//-- m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
//-- else
Brush_Draw(brush);
}
}
if (g_PrefsDlg.m_bGLLighting)
{
qglDisable (GL_LIGHTING);
}
//
//qglDepthMask ( 0 ); // Don't write to depth buffer
qglEnable ( GL_BLEND );
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for ( i = 0; i < m_nNumTransBrushes; i++ )
Brush_Draw (m_TransBrushes[i]);
//qglDepthMask ( 1 ); // Ok, write now
qglMatrixMode(GL_PROJECTION);
//
// now draw selected brushes
//
if (g_PrefsDlg.m_bGLLighting)
{
qglEnable (GL_LIGHTING);
}
qglTranslatef (g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]);
qglMatrixMode(GL_TEXTURE);
brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
// draw normally
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
//DrawLightRadius(brush);
//if (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint)
// continue;
Brush_Draw(brush);
}
// blend on top
qglMatrixMode(GL_PROJECTION);
qglDisable (GL_LIGHTING);
qglColor4f(1.0, 0.0, 0.0, 0.3);
qglEnable (GL_BLEND);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglDisable (GL_TEXTURE_2D);
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
if ( (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) ||
(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint) )
continue;
for (face=brush->brush_faces ; face ; face=face->next)
Face_Draw( face );
}
int nCount = g_ptrSelectedFaces.GetSize();
if (nCount > 0)
{
for (int i = 0; i < nCount; i++)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
Face_Draw(selFace);
}
}
// non-zbuffered outline
qglDisable (GL_BLEND);
qglDisable (GL_DEPTH_TEST);
qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
qglColor3f (1, 1, 1);
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
if (g_qeglobals.dontDrawSelectedOutlines || (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) ||
(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint))
continue;
for (face=brush->brush_faces ; face ; face=face->next)
Face_Draw( face );
}
// edge / vertex flags
if (g_qeglobals.d_select_mode == sel_vertex)
{
qglPointSize (4);
qglColor3f (0,1,0);
qglBegin (GL_POINTS);
for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
qglVertex3fv (g_qeglobals.d_points[i]);
qglEnd ();
qglPointSize (1);
}
else if (g_qeglobals.d_select_mode == sel_edge)
{
float *v1, *v2;
qglPointSize (4);
qglColor3f (0,0,1);
qglBegin (GL_POINTS);
for (i=0 ; i<g_qeglobals.d_numedges ; i++)
{
v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
}
qglEnd ();
qglPointSize (1);
}
g_splineList->draw(static_cast<qboolean>(g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint));
if (g_qeglobals.selectObject && (g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)) {
g_qeglobals.selectObject->drawSelection();
}
//
// draw pointfile
//
qglEnable(GL_DEPTH_TEST);
DrawPathLines ();
if (g_qeglobals.d_pointfile_display_list)
{
Pointfile_Draw();
// glCallList (g_qeglobals.d_pointfile_display_list);
}
// bind back to the default texture so that we don't have problems
// elsewhere using/modifying texture maps between contexts
qglBindTexture( GL_TEXTURE_2D, 0 );
#if 0
// area selection hack
if (g_qeglobals.d_select_mode == sel_area)
{
qglEnable (GL_BLEND);
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglColor4f(0.0, 0.0, 1.0, 0.25);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglRectfv(g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR);
qglDisable (GL_BLEND);
}
#endif
qglFinish();
QE_CheckOpenGLForErrors();
// Sys_EndWait();
if (m_Camera.timing)
{
end = Sys_DoubleTime ();
Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
}
}
/*
=================
RadiantInit
This is also called when you 'quit' in doom
=================
*/
void RadiantInit( void ) {
// make sure the renderer is initialized
if ( !renderSystem->IsOpenGLRunning() ) {
common->Printf( "no OpenGL running\n" );
return;
}
g_editorAlive = true;
// allocate a renderWorld and a soundWorld
if ( g_qeglobals.rw == NULL ) {
// jmarshall
// g_qeglobals.defaultEditorMaterial = declManager->FindMaterial( "_editordefault" );
RadiantInitTestWindow();
// jmarshall end
g_qeglobals.rw = renderSystem->AllocRenderWorld();
g_qeglobals.rw->InitFromMap( NULL );
}
if ( g_qeglobals.sw == NULL ) {
g_qeglobals.sw = soundSystem->AllocSoundWorld( g_qeglobals.rw );
}
if ( g_DoomInstance ) {
if ( ::IsWindowVisible( win32.hWnd ) ) {
::ShowWindow( win32.hWnd, SW_HIDE );
g_pParentWnd->ShowWindow( SW_SHOW );
g_pParentWnd->SetFocus();
}
} else {
sys->GrabMouseCursor( false );
g_DoomInstance = win32.hInstance;
CWinApp* pApp = AfxGetApp();
CWinThread *pThread = AfxGetThread();
InitAfx();
// App global initializations (rare)
pApp->InitApplication();
// Perform specific initializations
pThread->InitInstance();
qglFinish();
//qwglMakeCurrent(0, 0);
renderDevice->BindDeviceToWindow(win32.hDC);
// hide the doom window by default
::ShowWindow( win32.hWnd, SW_HIDE );
// jmarshall
toolInterfaceLocal.ShowDebugConsole();
// jmarshall end
}
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
void RB_BeginDrawingView (void) {
int clearBits = 0;
// sync with gl if needed
if ( r_finish->integer == 1 && !glState.finishCalled ) {
qglFinish ();
glState.finishCalled = qtrue;
}
if ( r_finish->integer == 0 ) {
glState.finishCalled = qtrue;
}
// we will need to change the projection matrix before drawing
// 2D images again
backEnd.projection2D = qfalse;
if (glRefConfig.framebufferObject)
{
// FIXME: HUGE HACK: render to the screen fbo if we've already postprocessed the frame and aren't drawing more world
// drawing more world check is in case of double renders, such as skyportals
if (backEnd.viewParms.targetFbo == NULL)
{
if (!tr.renderFbo || (backEnd.framePostProcessed && (backEnd.refdef.rdflags & RDF_NOWORLDMODEL)))
{
FBO_Bind(NULL);
}
else
{
FBO_Bind(tr.renderFbo);
}
}
else
{
FBO_Bind(backEnd.viewParms.targetFbo);
// FIXME: hack for cubemap testing
if (tr.renderCubeFbo && backEnd.viewParms.targetFbo == tr.renderCubeFbo)
{
//qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X + backEnd.viewParms.targetFboLayer, backEnd.viewParms.targetFbo->colorImage[0]->texnum, 0);
qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X + backEnd.viewParms.targetFboLayer, tr.cubemaps[backEnd.viewParms.targetFboCubemapIndex]->texnum, 0);
}
}
}
//
// set the modelview matrix for the viewer
//
SetViewportAndScissor();
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// clear relevant buffers
clearBits = GL_DEPTH_BUFFER_BIT;
if ( r_measureOverdraw->integer || r_shadows->integer == 2 )
{
clearBits |= GL_STENCIL_BUFFER_BIT;
}
if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) )
{
clearBits |= GL_COLOR_BUFFER_BIT; // FIXME: only if sky shaders have been used
#ifdef _DEBUG
qglClearColor( 0.8f, 0.7f, 0.4f, 1.0f ); // FIXME: get color of sky
#else
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // FIXME: get color of sky
#endif
}
// clear to white for shadow maps
if (backEnd.viewParms.flags & VPF_SHADOWMAP)
{
clearBits |= GL_COLOR_BUFFER_BIT;
qglClearColor( 1.0f, 1.0f, 1.0f, 1.0f );
}
// clear to black for cube maps
if (tr.renderCubeFbo && backEnd.viewParms.targetFbo == tr.renderCubeFbo)
{
clearBits |= GL_COLOR_BUFFER_BIT;
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
}
qglClear( clearBits );
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
{
RB_Hyperspace();
return;
}
else
{
backEnd.isHyperspace = qfalse;
}
glState.faceCulling = -1; // force face culling to set next time
// we will only draw a sun if there was sky rendered in this view
backEnd.skyRenderedThisView = qfalse;
// clip to the plane of the portal
if ( backEnd.viewParms.isPortal ) {
#if 0
float plane[4];
double plane2[4];
plane[0] = backEnd.viewParms.portalPlane.normal[0];
plane[1] = backEnd.viewParms.portalPlane.normal[1];
plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane);
plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane);
plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane);
plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3];
#endif
GL_SetModelviewMatrix( s_flipMatrix );
}
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
Used for cinematics.
=============
*/
void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) {
int i, j;
int start, end;
if ( !tr.registered ) {
return;
}
R_SyncRenderThread();
// we definately want to sync every frame for the cinematics
qglFinish();
start = end = 0;
if ( r_speeds->integer ) {
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0 ; ( 1 << i ) < cols ; i++ ) {
}
for ( j = 0 ; ( 1 << j ) < rows ; j++ ) {
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows) {
ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
}
GL_Bind( tr.scratchImage[client] );
// if the scratchImage isn't in the format we want, specify it as a new texture
if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
} else {
if (dirty) {
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
// it and don't try and do a texture compression
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
}
}
if ( r_speeds->integer ) {
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
RB_SetGL2D();
qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
qglBegin (GL_QUADS);
qglTexCoord2f ( 0.5f / cols, 0.5f / rows );
qglVertex2f (x, y);
qglTexCoord2f ( ( cols - 0.5f ) / cols , 0.5f / rows );
qglVertex2f (x+w, y);
qglTexCoord2f ( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows );
qglVertex2f (x+w, y+h);
qglTexCoord2f ( 0.5f / cols, ( rows - 0.5f ) / rows );
qglVertex2f (x, y+h);
qglEnd ();
}
/*
=============
RB_SwapBuffers
=============
*/
const void *RB_SwapBuffers( const void *data ) {
const swapBuffersCommand_t *cmd;
// finish any 2D drawing if needed
if ( tess.numIndexes ) {
RB_EndSurface();
}
// texture swapping test
if ( r_showImages->integer ) {
RB_ShowImages();
}
cmd = (const swapBuffersCommand_t *)data;
// we measure overdraw by reading back the stencil buffer and
// counting up the number of increments that have happened
if ( r_measureOverdraw->integer ) {
int i;
long sum = 0;
unsigned char *stencilReadback;
stencilReadback = ri.Hunk_AllocateTempMemory( glConfig.vidWidth * glConfig.vidHeight );
qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencilReadback );
for ( i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++ ) {
sum += stencilReadback[i];
}
backEnd.pc.c_overDraw += sum;
ri.Hunk_FreeTempMemory( stencilReadback );
}
if (glRefConfig.framebufferObject)
{
if (!backEnd.framePostProcessed)
{
if (tr.msaaResolveFbo && r_hdr->integer)
{
// Resolving an RGB16F MSAA FBO to the screen messes with the brightness, so resolve to an RGB16F FBO first
FBO_FastBlit(tr.renderFbo, NULL, tr.msaaResolveFbo, NULL, GL_COLOR_BUFFER_BIT, GL_NEAREST);
FBO_FastBlit(tr.msaaResolveFbo, NULL, NULL, NULL, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
else if (tr.renderFbo)
{
FBO_FastBlit(tr.renderFbo, NULL, NULL, NULL, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
}
}
if ( !glState.finishCalled ) {
qglFinish();
}
GLimp_LogComment( "***************** RB_SwapBuffers *****************\n\n\n" );
GLimp_EndFrame();
backEnd.framePostProcessed = qfalse;
backEnd.projection2D = qfalse;
return (const void *)(cmd + 1);
}