void idGLWidget::OnPaint()
{
if (!initialized)
{
CDC *dc = GetDC();
QEW_SetupPixelFormat(dc->m_hDC);
ReleaseDC(dc);
initialized = true;
}
CPaintDC dc(this); // device context for painting
CRect rect;
GetClientRect(rect);
if (!qwglMakeCurrent(dc.m_hDC, win32.hGLRC))
{
}
qglViewport(0, 0, rect.Width(), rect.Height());
qglScissor(0, 0, rect.Width(), rect.Height());
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglClearColor (0.4f, 0.4f, 0.4f, 0.7f);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_BLEND);
qglOrtho(0, rect.Width(), 0, rect.Height(), -256, 256);
if (drawable)
{
drawable->draw(1, 1, rect.Width()-1, rect.Height()-1);
}
else
{
qglViewport(0, 0, rect.Width(), rect.Height());
qglScissor(0, 0, rect.Width(), rect.Height());
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglClearColor (0.4f, 0.4f, 0.4f, 0.7f);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
qwglSwapBuffers(dc);
qglFlush();
qwglMakeCurrent(win32.hDC, win32.hGLRC);
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D(void)
{
backEnd.projection2D = qtrue;
// set 2D virtual screen size
qglViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
qglScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
GL_State(GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA);
qglDisable(GL_FOG); //----(SA) added
qglDisable(GL_CULL_FACE);
qglDisable(GL_CLIP_PLANE0);
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D (void) {
if ( tess.numIndexes | tess.numVertexes )
Com_Printf(" Going 2d with verts?" );
backEnd.projection2D = qtrue;
backEnd.currentModel = 0;
// set 2D virtual screen size
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
qglOrtho (0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity ();
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_Cull( CT_TWO_SIDED );
qglDisable( GL_CLIP_PLANE0 );
// set time for 2D shaders
// tess.shaderTime = ri.Milliseconds();
}
/*
* RB_Viewport
*/
void RB_Viewport( int x, int y, int w, int h )
{
rb.gl.viewport[0] = x;
rb.gl.viewport[1] = y;
rb.gl.viewport[2] = w;
rb.gl.viewport[3] = h;
qglViewport( x, rb.gl.fbHeight - h - y, w, h );
}
static void SetViewportAndScissor( void ) {
GL_SetProjectionMatrix( backEnd.viewParms.projectionMatrix );
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
/*
=================
R_BloomScreen
=================
*/
void R_BloomScreen( void )
{
if( !r_bloom->integer )
return;
if(r_bloom_sky_only->integer)
return;
if ( backEnd.doneBloom )
return;
if ( !backEnd.doneSurfaces )
return;
backEnd.doneBloom = qtrue;
if( !bloom.started ) {
R_Bloom_InitTextures();
if( !bloom.started )
return;
}
if ( !backEnd.projection2D )
RB_SetGL2D();
#if 0
// set up full screen workspace
GL_TexEnv( GL_MODULATE );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity ();
qglOrtho( 0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity ();
GL_Cull( CT_TWO_SIDED );
#endif
qglColor4f( 1, 1, 1, 1 );
//Backup the old screen in a texture
R_Bloom_BackupScreen();
// create the bloom texture using one of a few methods
if(r_bloom_cascade->integer)
R_Bloom_Cascaded();
else
R_Bloom_WarsowEffect ();
// R_Bloom_CreateEffect();
// restore the screen-backup to the screen
R_Bloom_RestoreScreen();
// Do the final pass using the bloom texture for the final effect
R_Bloom_DrawEffect ();
// LEILEI - Lens Bloom Hack
// The concept of this is to inverse the coordinates on both X and Y,
// then scale outward using the offset value applied, as well as the modulated color
// applied to give a rainbow streak effect. Most effective with high bloom darkness
// values.
if(r_bloom_reflection->integer)
R_Bloom_LensEffect ();
}
void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
/*
==================
GL_Viewport
==================
*/
void GL_Viewport (rect_t rect){
if (glState.viewportX == rect.x && glState.viewportY == rect.y && glState.viewportWidth == rect.width && glState.viewportHeight == rect.height)
return;
glState.viewportX = rect.x;
glState.viewportY = rect.y;
glState.viewportWidth = rect.width;
glState.viewportHeight = rect.height;
qglViewport(rect.x, rect.y, rect.width, rect.height);
}
static void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
Matrix4Copy(backEnd.viewParms.projectionMatrix, glState.currentProjectionMatrix);
Matrix4Multiply(glState.currentProjectionMatrix, glState.currentModelViewMatrix, glState.currentModelViewProjectionMatrix);
}
void idGLDrawableView::draw(int x, int y, int w, int h)
{
int i;
renderView_t refdef;
const idMaterial *mat = material;
if (mat)
{
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
UpdateLights();
// render it
renderSystem->BeginFrame(w, h);
memset( &refdef, 0, sizeof( refdef ) );
UpdateCamera( &refdef );
// Copy global shaderparms to view
for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ )
{
refdef.shaderParms[ i ] = globalParms[ i ];
}
refdef.width = SCREEN_WIDTH;
refdef.height = SCREEN_HEIGHT;
refdef.fov_x = 90;
refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;
refdef.time = eventLoop->Milliseconds();
world->RenderScene( &refdef );
if ( showLights )
{
drawLights( &refdef );
}
renderSystem->EndFrame( NULL, NULL );
world->DebugClearLines( refdef.time );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
}
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D (void) {
backEnd.projection2D = qtrue;
// set 2D virtual screen size
#ifdef IPHONE
if ( glConfig.vidRotation == 90.0 || glConfig.vidRotation == 270.0 )
{
qglViewport ( 0, 0, glConfig.vidHeight, glConfig.vidWidth );
qglScissor( 0, 0, glConfig.vidHeight, glConfig.vidWidth );
}
else
#endif // IPHONE
{
qglViewport ( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
}
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
#ifdef IPHONE
qglRotatef (glConfig.vidRotation, 0, 0, 1);
qglTranslatef (0, 0, 0);
#endif // IPHONE
qglOrtho (0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity ();
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
qglDisable( GL_CULL_FACE );
qglDisable( GL_CLIP_PLANE0 );
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
}
static void SetViewportAndScissor( void ) {
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode( GL_MODELVIEW );
// set the window clipping
qglViewport( backEnd.viewParms.viewportX,
backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportHeight );
// TODO: insert handling for widescreen? (when looking through camera)
qglScissor( backEnd.viewParms.viewportX,
backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportHeight );
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D (void) {
mat4_t matrix;
int width, height;
if (backEnd.projection2D && backEnd.last2DFBO == glState.currentFBO)
return;
backEnd.projection2D = qtrue;
backEnd.last2DFBO = glState.currentFBO;
if (glState.currentFBO)
{
width = glState.currentFBO->width;
height = glState.currentFBO->height;
}
else
{
width = glConfig.vidWidth;
height = glConfig.vidHeight;
}
// set 2D virtual screen size
qglViewport( 0, 0, width, height );
qglScissor( 0, 0, width, height );
Mat4Ortho(0, width, height, 0, 0, 1, matrix);
GL_SetProjectionMatrix(matrix);
Mat4Identity(matrix);
GL_SetModelviewMatrix(matrix);
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
qglDisable( GL_CULL_FACE );
qglDisable( GL_CLIP_PLANE0 );
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
// reset color scaling
backEnd.refdef.colorScale = 1.0f;
}
/*
=============
RB_SetGL2D
This is not used by the normal game paths, just by some tools
=============
*/
void RB_SetGL2D( void ) {
// set 2D virtual screen size
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
if ( r_useScissor.GetBool() ) {
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
}
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, 640, 480, 0, 0, 1 ); // always assume 640x480 virtual coordinates
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
GL_State( GLS_DEPTHFUNC_ALWAYS |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_Cull( CT_TWO_SIDED );
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
}
static void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
if(r_subviewScissor->integer)
{
qglScissor( backEnd.viewParms.scissorMinX, backEnd.viewParms.scissorMinY,
backEnd.viewParms.scissorMaxX - backEnd.viewParms.scissorMinX,
backEnd.viewParms.scissorMaxY - backEnd.viewParms.scissorMinY );
}
else
{
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
}
/*
=================
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) {
// set the modelview matrix for the viewer
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewDef->projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( tr.viewportOffset[0] + backEnd.viewDef->viewport.x1,
tr.viewportOffset[1] + backEnd.viewDef->viewport.y1,
backEnd.viewDef->viewport.x2 + 1 - backEnd.viewDef->viewport.x1,
backEnd.viewDef->viewport.y2 + 1 - backEnd.viewDef->viewport.y1 );
// the scissor may be smaller than the viewport for subviews
qglScissor( tr.viewportOffset[0] + backEnd.viewDef->viewport.x1 + backEnd.viewDef->scissor.x1,
tr.viewportOffset[1] + backEnd.viewDef->viewport.y1 + backEnd.viewDef->scissor.y1,
backEnd.viewDef->scissor.x2 + 1 - backEnd.viewDef->scissor.x1,
backEnd.viewDef->scissor.y2 + 1 - backEnd.viewDef->scissor.y1 );
backEnd.currentScissor = backEnd.viewDef->scissor;
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// we don't have to clear the depth / stencil buffer for 2D rendering
if ( backEnd.viewDef->viewEntitys ) {
qglStencilMask( 0xff );
// some cards may have 7 bit stencil buffers, so don't assume this
// should be 128
qglClearStencil( 1<<(glConfig.stencilBits-1) );
qglClear( GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
qglEnable( GL_DEPTH_TEST );
} else {
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
}
backEnd.glState.faceCulling = -1; // force face culling to set next time
GL_Cull( CT_FRONT_SIDED );
}
/*
=================
R_PostprocessScreen
=================
*/
void R_PostprocessScreen( void )
{
if( !postprocess )
return;
if ( backEnd.donepostproc )
return;
if ( !backEnd.doneSurfaces )
return;
backEnd.donepostproc = qtrue;
if( !postproc.started ) {
R_Postprocess_InitTextures();
if( !postproc.started )
return;
}
if ( !backEnd.projection2D )
RB_SetGL2D();
#if 0
// set up full screen workspace
GL_TexEnv( GL_MODULATE );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity ();
qglOrtho( 0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity ();
GL_Cull( CT_TWO_SIDED );
#endif
qglColor4f( 1, 1, 1, 1 );
//Backup the old screen in a texture
R_Postprocess_BackupScreen();
//Redraw texture using GLSL program
R_Bloom_RestoreScreen_Postprocessed();
}
void idGLDrawable::draw(int x, int y, int w, int h) {
GL_State( GLS_DEFAULT );
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
qglLineWidth(0.5);
qglColor3f(1, 1, 1);
globalImages->BindNull();
qglBegin(GL_LINE_LOOP);
qglColor3f(1, 0, 0);
qglVertex2f(x + 3, y + 3);
qglColor3f(0, 1, 0);
qglVertex2f(x + 3, h - 3);
qglColor3f(0, 0, 1);
qglVertex2f(w - 3, h - 3);
qglColor3f(1, 1, 1);
qglVertex2f(w - 3, y + 3);
qglEnd();
}
// Based on RB_SetGL2D(): FIXME? Code duplication can probably be avoided.
static void Unicode_Setup2D (void) {
backEnd.projection2D = qtrue;
// set 2D virtual screen size
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
qglOrtho (0, glConfig.vidWidth, glConfig.vidHeight, 0, -200, 200); // This changed. FIXME? Perhaps do it beter.
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity ();
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
qglDisable( GL_CULL_FACE );
qglDisable( GL_CLIP_PLANE0 );
qglDisable( GL_CLIP_PLANE1 );
// set time for 2D shaders
//backEnd.refdef.time = ri.Milliseconds();
//backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
}
void FBO_BlitFromTexture(struct image_s *src, ivec4_t inSrcBox, vec2_t inSrcTexScale, FBO_t *dst, ivec4_t inDstBox, struct shaderProgram_s *shaderProgram, vec4_t inColor, int blend)
{
ivec4_t dstBox, srcBox;
vec2_t srcTexScale;
vec4_t color;
vec4_t quadVerts[4];
vec2_t texCoords[4];
vec2_t invTexRes;
FBO_t *oldFbo = glState.currentFBO;
mat4_t projection;
int width, height;
if (!src)
return;
if (inSrcBox)
{
VectorSet4(srcBox, inSrcBox[0], inSrcBox[1], inSrcBox[0] + inSrcBox[2], inSrcBox[1] + inSrcBox[3]);
}
else
{
VectorSet4(srcBox, 0, 0, src->width, src->height);
}
// framebuffers are 0 bottom, Y up.
if (inDstBox)
{
if (dst)
{
dstBox[0] = inDstBox[0];
dstBox[1] = dst->height - inDstBox[1] - inDstBox[3];
dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[3] = dst->height - inDstBox[1];
}
else
{
dstBox[0] = inDstBox[0];
dstBox[1] = glConfig.vidHeight - inDstBox[1] - inDstBox[3];
dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[3] = glConfig.vidHeight - inDstBox[1];
}
}
else if (dst)
{
VectorSet4(dstBox, 0, dst->height, dst->width, 0);
}
else
{
VectorSet4(dstBox, 0, glConfig.vidHeight, glConfig.vidWidth, 0);
}
if (inSrcTexScale)
{
VectorCopy2(inSrcTexScale, srcTexScale);
}
else
{
srcTexScale[0] = srcTexScale[1] = 1.0f;
}
if (inColor)
{
VectorCopy4(inColor, color);
}
else
{
VectorCopy4(colorWhite, color);
}
if (!shaderProgram)
{
shaderProgram = &tr.textureColorShader;
}
FBO_Bind(dst);
if (glState.currentFBO)
{
width = glState.currentFBO->width;
height = glState.currentFBO->height;
}
else
{
width = glConfig.vidWidth;
height = glConfig.vidHeight;
}
qglViewport( 0, 0, width, height );
qglScissor( 0, 0, width, height );
Mat4Ortho(0, width, height, 0, 0, 1, projection);
qglDisable( GL_CULL_FACE );
GL_BindToTMU(src, TB_COLORMAP);
VectorSet4(quadVerts[0], dstBox[0], dstBox[1], 0, 1);
VectorSet4(quadVerts[1], dstBox[2], dstBox[1], 0, 1);
VectorSet4(quadVerts[2], dstBox[2], dstBox[3], 0, 1);
VectorSet4(quadVerts[3], dstBox[0], dstBox[3], 0, 1);
texCoords[0][0] = srcBox[0] / (float)src->width; texCoords[0][1] = 1.0f - srcBox[1] / (float)src->height;
texCoords[1][0] = srcBox[2] / (float)src->width; texCoords[1][1] = 1.0f - srcBox[1] / (float)src->height;
texCoords[2][0] = srcBox[2] / (float)src->width; texCoords[2][1] = 1.0f - srcBox[3] / (float)src->height;
texCoords[3][0] = srcBox[0] / (float)src->width; texCoords[3][1] = 1.0f - srcBox[3] / (float)src->height;
invTexRes[0] = 1.0f / src->width * srcTexScale[0];
invTexRes[1] = 1.0f / src->height * srcTexScale[1];
GL_State( blend );
GLSL_BindProgram(shaderProgram);
GLSL_SetUniformMat4(shaderProgram, UNIFORM_MODELVIEWPROJECTIONMATRIX, projection);
GLSL_SetUniformVec4(shaderProgram, UNIFORM_COLOR, color);
GLSL_SetUniformVec2(shaderProgram, UNIFORM_INVTEXRES, invTexRes);
GLSL_SetUniformVec2(shaderProgram, UNIFORM_AUTOEXPOSUREMINMAX, tr.refdef.autoExposureMinMax);
GLSL_SetUniformVec3(shaderProgram, UNIFORM_TONEMINAVGMAXLINEAR, tr.refdef.toneMinAvgMaxLinear);
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes);
FBO_Bind(oldFbo);
}
/*
==============
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)));
}
}
void idGLDrawableModel::draw(int x, int y, int w, int h) {
if ( !worldModel ) {
return;
}
if ( worldModel->IsDynamicModel() != DM_STATIC ) {
//return;
}
rect.Set( x, y, w, h );
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
if (worldDirty) {
//InitWorld();
world->InitFromMap( NULL );
renderLight_t parms;
idDict spawnArgs;
spawnArgs.Set("classname", "light");
spawnArgs.Set("name", "light_1");
spawnArgs.Set("origin", "-128 0 0");
idStr str;
sprintf(str, "%f %f %f", light, light, light);
spawnArgs.Set("_color", str);
gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &parms );
lightDef = world->AddLightDef( &parms );
renderEntity_t worldEntity;
memset( &worldEntity, 0, sizeof( worldEntity ) );
spawnArgs.Clear();
spawnArgs.Set("classname", "func_static");
spawnArgs.Set("name", spawnArgs.GetString("model"));
spawnArgs.Set("origin", "0 0 0");
if ( skinStr.Length() ) {
spawnArgs.Set( "skin", skinStr );
}
gameEdit->ParseSpawnArgsToRenderEntity(&spawnArgs, &worldEntity);
worldEntity.hModel = worldModel;
worldEntity.axis = rotation.ToMat3();
worldEntity.shaderParms[0] = 1;
worldEntity.shaderParms[1] = 1;
worldEntity.shaderParms[2] = 1;
worldEntity.shaderParms[3] = 1;
modelDef = world->AddEntityDef( &worldEntity );
worldDirty = false;
}
renderView_t refdef;
// render it
renderSystem->BeginFrame(w, h);
memset( &refdef, 0, sizeof( refdef ) );
refdef.vieworg.Set(zOffset, xOffset, -yOffset);
refdef.viewaxis = idAngles(0,0,0).ToMat3();
refdef.shaderParms[0] = 1;
refdef.shaderParms[1] = 1;
refdef.shaderParms[2] = 1;
refdef.shaderParms[3] = 1;
refdef.width = SCREEN_WIDTH;
refdef.height = SCREEN_HEIGHT;
refdef.fov_x = 90;
refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;
refdef.time = eventLoop->Milliseconds();
world->RenderScene( &refdef );
int frontEnd, backEnd;
renderSystem->EndFrame( &frontEnd, &backEnd );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
}
void idGLDrawableMaterial::draw(int x, int y, int w, int h) {
const idMaterial *mat = material;
if (mat) {
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
if (worldDirty) {
InitWorld();
renderLight_t parms;
idDict spawnArgs;
spawnArgs.Set("classname", "light");
spawnArgs.Set("name", "light_1");
spawnArgs.Set("origin", "0 0 0");
idStr str;
sprintf(str, "%f %f %f", light, light, light);
spawnArgs.Set("_color", str);
gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &parms );
lightDef = world->AddLightDef( &parms );
idImage *img = (mat->GetNumStages() > 0) ? mat->GetStage(0)->texture.image : mat->GetEditorImage();
if (img == NULL) {
common->Warning("Unable to load image for preview for %s", mat->GetName());
return;
}
int width = img->uploadWidth;
int height = img->uploadHeight;
width *= scale;
height *= scale;
srfTriangles_t *tris = worldModel->AllocSurfaceTriangles( 4, 6 );
tris->numVerts = 4;
tris->numIndexes = 6;
tris->indexes[0] = 0;
tris->indexes[1] = 1;
tris->indexes[2] = 2;
tris->indexes[3] = 3;
tris->indexes[4] = 1;
tris->indexes[5] = 0;
tris->verts[0].xyz.x = 64;
tris->verts[0].xyz.y = -xOffset + 0 - width / 2;
tris->verts[0].xyz.z = yOffset + 0 - height / 2;
tris->verts[0].st.x = 1;
tris->verts[0].st.y = 1;
tris->verts[1].xyz.x = 64;
tris->verts[1].xyz.y = -xOffset + width / 2;
tris->verts[1].xyz.z = yOffset + height / 2;
tris->verts[1].st.x = 0;
tris->verts[1].st.y = 0;
tris->verts[2].xyz.x = 64;
tris->verts[2].xyz.y = -xOffset + 0 - width / 2;
tris->verts[2].xyz.z = yOffset + height / 2;
tris->verts[2].st.x = 1;
tris->verts[2].st.y = 0;
tris->verts[3].xyz.x = 64;
tris->verts[3].xyz.y = -xOffset + width / 2;
tris->verts[3].xyz.z = yOffset + 0 - height / 2;
tris->verts[3].st.x = 0;
tris->verts[3].st.y = 1;
tris->verts[0].normal = tris->verts[1].xyz.Cross(tris->verts[3].xyz);
tris->verts[1].normal = tris->verts[2].normal = tris->verts[3].normal = tris->verts[0].normal;
AddTris(tris, mat);
worldModel->FinishSurfaces();
renderEntity_t worldEntity;
memset( &worldEntity, 0, sizeof( worldEntity ) );
if ( mat->HasGui() ) {
worldEntity.gui[ 0 ] = mat->GlobalGui();
}
worldEntity.hModel = worldModel;
worldEntity.axis = mat3_default;
worldEntity.shaderParms[0] = 1;
worldEntity.shaderParms[1] = 1;
worldEntity.shaderParms[2] = 1;
worldEntity.shaderParms[3] = 1;
modelDef = world->AddEntityDef( &worldEntity );
worldDirty = false;
}
renderView_t refdef;
// render it
renderSystem->BeginFrame(w, h);
memset( &refdef, 0, sizeof( refdef ) );
refdef.vieworg.Set(viewAngle, 0, 0);
refdef.viewaxis = idAngles(0,0,0).ToMat3();
refdef.shaderParms[0] = 1;
refdef.shaderParms[1] = 1;
refdef.shaderParms[2] = 1;
refdef.shaderParms[3] = 1;
refdef.width = SCREEN_WIDTH;
refdef.height = SCREEN_HEIGHT;
refdef.fov_x = 90;
refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;
refdef.time = eventLoop->Milliseconds();
world->RenderScene( &refdef );
int frontEnd, backEnd;
renderSystem->EndFrame( &frontEnd, &backEnd );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
}
}
/*
==================
GL_SetDefaultState
==================
*/
void GL_SetDefaultState (){
int i;
QGL_LogPrintf("---------- GL_SetDefaultState ----------\n");
// Reset the state manager
glState.projectionMatrixIdentity = true;
glState.modelviewMatrixIdentity = true;
for (i = 0; i < MAX_TEXTURE_UNITS; i++)
glState.textureMatrixIdentity[i] = true;
for (i = 0; i < MAX_TEXTURE_UNITS; i++)
glState.texture[i] = NULL;
glState.program = NULL;
glState.indexBuffer = NULL;
glState.vertexBuffer = NULL;
glState.viewportX = 0;
glState.viewportY = 0;
glState.viewportWidth = glConfig.videoWidth;
glState.viewportHeight = glConfig.videoHeight;
glState.scissorX = 0;
glState.scissorY = 0;
glState.scissorWidth = glConfig.videoWidth;
glState.scissorHeight = glConfig.videoHeight;
glState.depthBoundsMin = 0.0f;
glState.depthBoundsMax = 1.0f;
glState.texUnit = 0;
for (i = 0; i < MAX_TEXTURE_UNITS; i++){
glState.texTarget[i] = 0;
glState.texEnv[i] = GL_MODULATE;
glState.texGen[i][0] = GL_OBJECT_LINEAR;
glState.texGen[i][1] = GL_OBJECT_LINEAR;
glState.texGen[i][2] = GL_OBJECT_LINEAR;
glState.texGen[i][3] = GL_OBJECT_LINEAR;
}
glState.cullFace = false;
glState.polygonOffsetFill = false;
glState.polygonOffsetLine = false;
glState.blend = false;
glState.alphaTest = false;
glState.depthTest = false;
glState.stencilTest = false;
for (i = 0; i < MAX_TEXTURE_UNITS; i++){
glState.textureGen[i][0] = false;
glState.textureGen[i][1] = false;
glState.textureGen[i][2] = false;
glState.textureGen[i][3] = false;
}
glState.cullMode = GL_FRONT;
glState.polygonMode = GL_FILL;
glState.polygonOffsetFactor = 0.0f;
glState.polygonOffsetUnits = 0.0f;
glState.blendSrc = GL_ONE;
glState.blendDst = GL_ZERO;
glState.blendMode = GL_FUNC_ADD;
glState.alphaFunc = GL_GREATER;
glState.alphaFuncRef = 0.0f;
glState.depthFunc = GL_LEQUAL;
glState.stencilFunc[0] = GL_ALWAYS;
glState.stencilFunc[1] = GL_ALWAYS;
glState.stencilFuncRef[0] = 0;
glState.stencilFuncRef[1] = 0;
glState.stencilFuncMask[0] = 255;
glState.stencilFuncMask[1] = 255;
glState.stencilOpFail[0] = GL_KEEP;
glState.stencilOpFail[1] = GL_KEEP;
glState.stencilOpZFail[0] = GL_KEEP;
glState.stencilOpZFail[1] = GL_KEEP;
glState.stencilOpZPass[0] = GL_KEEP;
glState.stencilOpZPass[1] = GL_KEEP;
glState.depthMin = 0.0f;
glState.depthMax = 1.0f;
glState.colorMask[0] = GL_TRUE;
glState.colorMask[1] = GL_TRUE;
glState.colorMask[2] = GL_TRUE;
glState.colorMask[3] = GL_TRUE;
glState.depthMask = GL_TRUE;
glState.stencilMask[0] = 255;
glState.stencilMask[1] = 255;
// Set default state
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
for (i = MAX_TEXTURE_UNITS - 1; i >= 0; i--){
if (i >= glConfig.maxTextureImageUnits)
continue;
if (i >= glConfig.maxTextureUnits){
qglActiveTexture(GL_TEXTURE0 + i);
qglBindTexture(GL_TEXTURE_2D, 0);
qglBindTexture(GL_TEXTURE_3D, 0);
qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);
qglBindTexture(GL_TEXTURE_2D_ARRAY, 0);
continue;
}
qglActiveTexture(GL_TEXTURE0 + i);
qglMatrixMode(GL_TEXTURE);
qglLoadIdentity();
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_TEXTURE_3D);
qglDisable(GL_TEXTURE_CUBE_MAP);
qglDisable(GL_TEXTURE_2D_ARRAY);
qglBindTexture(GL_TEXTURE_2D, 0);
qglBindTexture(GL_TEXTURE_3D, 0);
qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);
qglBindTexture(GL_TEXTURE_2D_ARRAY, 0);
qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglDisable(GL_TEXTURE_GEN_S);
qglDisable(GL_TEXTURE_GEN_T);
qglDisable(GL_TEXTURE_GEN_R);
qglDisable(GL_TEXTURE_GEN_Q);
qglTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
}
qglDisable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
qglUseProgram(0);
qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
qglBindBuffer(GL_ARRAY_BUFFER, 0);
qglViewport(0, 0, glConfig.videoWidth, glConfig.videoHeight);
qglEnable(GL_SCISSOR_TEST);
qglScissor(0, 0, glConfig.videoWidth, glConfig.videoHeight);
qglEnable(GL_DEPTH_BOUNDS_TEST_EXT);
qglDepthBoundsEXT(0.0f, 1.0f);
qglFrontFace(GL_CCW);
qglShadeModel(GL_SMOOTH);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
qglDisable(GL_CULL_FACE);
qglCullFace(GL_FRONT);
qglDisable(GL_POLYGON_OFFSET_FILL);
qglDisable(GL_POLYGON_OFFSET_LINE);
qglPolygonOffset(0.0f, 0.0f);
qglDisable(GL_BLEND);
qglBlendFunc(GL_ONE, GL_ZERO);
qglBlendEquation(GL_FUNC_ADD);
qglDisable(GL_ALPHA_TEST);
qglAlphaFunc(GL_GREATER, 0.0f);
qglDisable(GL_DEPTH_TEST);
qglDepthFunc(GL_LEQUAL);
qglDisable(GL_STENCIL_TEST);
qglStencilFunc(GL_ALWAYS, 128, 255);
qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
qglDepthRange(0.0f, 1.0f);
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
qglDepthMask(GL_TRUE);
qglStencilMask(255);
qglDisable(GL_DEPTH_CLAMP);
qglDisable(GL_CLIP_PLANE0);
if (glConfig.multiSamples > 1){
qglDisable(GL_MULTISAMPLE);
qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
}
qglClearColor(0.0f, 0.0f, 0.0f, 1.0f);
qglClearDepth(1.0f);
qglClearStencil(128);
qglEnableClientState(GL_VERTEX_ARRAY);
qglDisableVertexAttribArray(GL_ATTRIB_NORMAL);
qglDisableVertexAttribArray(GL_ATTRIB_TANGENT1);
qglDisableVertexAttribArray(GL_ATTRIB_TANGENT2);
qglDisableVertexAttribArray(GL_ATTRIB_TEXCOORD);
qglDisableVertexAttribArray(GL_ATTRIB_COLOR);
QGL_LogPrintf("--------------------\n");
}
/*
=============
RB_PostProcess
=============
*/
const void *RB_PostProcess(const void *data)
{
const postProcessCommand_t *cmd = data;
FBO_t *srcFbo;
ivec4_t srcBox, dstBox;
qboolean autoExposure;
// finish any 2D drawing if needed
if(tess.numIndexes)
RB_EndSurface();
if (!glRefConfig.framebufferObject || !r_postProcess->integer)
{
// do nothing
return (const void *)(cmd + 1);
}
if (cmd)
{
backEnd.refdef = cmd->refdef;
backEnd.viewParms = cmd->viewParms;
}
srcFbo = tr.renderFbo;
if (tr.msaaResolveFbo)
{
// Resolve the MSAA before anything else
// Can't resolve just part of the MSAA FBO, so multiple views will suffer a performance hit here
FBO_FastBlit(tr.renderFbo, NULL, tr.msaaResolveFbo, NULL, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
srcFbo = tr.msaaResolveFbo;
}
dstBox[0] = backEnd.viewParms.viewportX;
dstBox[1] = backEnd.viewParms.viewportY;
dstBox[2] = backEnd.viewParms.viewportWidth;
dstBox[3] = backEnd.viewParms.viewportHeight;
if (r_ssao->integer)
{
srcBox[0] = backEnd.viewParms.viewportX * tr.screenSsaoImage->width / (float)glConfig.vidWidth;
srcBox[1] = backEnd.viewParms.viewportY * tr.screenSsaoImage->height / (float)glConfig.vidHeight;
srcBox[2] = backEnd.viewParms.viewportWidth * tr.screenSsaoImage->width / (float)glConfig.vidWidth;
srcBox[3] = backEnd.viewParms.viewportHeight * tr.screenSsaoImage->height / (float)glConfig.vidHeight;
FBO_Blit(tr.screenSsaoFbo, srcBox, NULL, srcFbo, dstBox, NULL, NULL, GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO);
}
srcBox[0] = backEnd.viewParms.viewportX;
srcBox[1] = backEnd.viewParms.viewportY;
srcBox[2] = backEnd.viewParms.viewportWidth;
srcBox[3] = backEnd.viewParms.viewportHeight;
if (srcFbo)
{
if (r_hdr->integer && (r_toneMap->integer || r_forceToneMap->integer))
{
autoExposure = r_autoExposure->integer || r_forceAutoExposure->integer;
RB_ToneMap(srcFbo, srcBox, NULL, dstBox, autoExposure);
}
else if (r_cameraExposure->value == 0.0f)
{
FBO_FastBlit(srcFbo, srcBox, NULL, dstBox, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
else
{
vec4_t color;
color[0] =
color[1] =
color[2] = pow(2, r_cameraExposure->value); //exp2(r_cameraExposure->value);
color[3] = 1.0f;
FBO_Blit(srcFbo, srcBox, NULL, NULL, dstBox, NULL, color, 0);
}
}
if (r_drawSunRays->integer)
RB_SunRays(NULL, srcBox, NULL, dstBox);
if (1)
RB_BokehBlur(NULL, srcBox, NULL, dstBox, backEnd.refdef.blurFactor);
else
RB_GaussianBlur(backEnd.refdef.blurFactor);
#if 0
if (0)
{
vec4_t quadVerts[4];
vec2_t texCoords[4];
ivec4_t iQtrBox;
vec4_t box;
vec4_t viewInfo;
static float scale = 5.0f;
scale -= 0.005f;
if (scale < 0.01f)
scale = 5.0f;
FBO_FastBlit(NULL, NULL, tr.quarterFbo[0], NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR);
iQtrBox[0] = backEnd.viewParms.viewportX * tr.quarterImage[0]->width / (float)glConfig.vidWidth;
iQtrBox[1] = backEnd.viewParms.viewportY * tr.quarterImage[0]->height / (float)glConfig.vidHeight;
iQtrBox[2] = backEnd.viewParms.viewportWidth * tr.quarterImage[0]->width / (float)glConfig.vidWidth;
iQtrBox[3] = backEnd.viewParms.viewportHeight * tr.quarterImage[0]->height / (float)glConfig.vidHeight;
qglViewport(iQtrBox[0], iQtrBox[1], iQtrBox[2], iQtrBox[3]);
qglScissor(iQtrBox[0], iQtrBox[1], iQtrBox[2], iQtrBox[3]);
VectorSet4(box, 0.0f, 0.0f, 1.0f, 1.0f);
texCoords[0][0] = box[0]; texCoords[0][1] = box[3];
texCoords[1][0] = box[2]; texCoords[1][1] = box[3];
texCoords[2][0] = box[2]; texCoords[2][1] = box[1];
texCoords[3][0] = box[0]; texCoords[3][1] = box[1];
VectorSet4(box, -1.0f, -1.0f, 1.0f, 1.0f);
VectorSet4(quadVerts[0], box[0], box[3], 0, 1);
VectorSet4(quadVerts[1], box[2], box[3], 0, 1);
VectorSet4(quadVerts[2], box[2], box[1], 0, 1);
VectorSet4(quadVerts[3], box[0], box[1], 0, 1);
GL_State(GLS_DEPTHTEST_DISABLE);
VectorSet4(viewInfo, backEnd.viewParms.zFar / r_znear->value, backEnd.viewParms.zFar, 0.0, 0.0);
viewInfo[2] = scale / (float)(tr.quarterImage[0]->width);
viewInfo[3] = scale / (float)(tr.quarterImage[0]->height);
FBO_Bind(tr.quarterFbo[1]);
GLSL_BindProgram(&tr.depthBlurShader[2]);
GL_BindToTMU(tr.quarterImage[0], TB_COLORMAP);
GLSL_SetUniformVec4(&tr.depthBlurShader[2], UNIFORM_VIEWINFO, viewInfo);
RB_InstantQuad2(quadVerts, texCoords);
FBO_Bind(tr.quarterFbo[0]);
GLSL_BindProgram(&tr.depthBlurShader[3]);
GL_BindToTMU(tr.quarterImage[1], TB_COLORMAP);
GLSL_SetUniformVec4(&tr.depthBlurShader[3], UNIFORM_VIEWINFO, viewInfo);
RB_InstantQuad2(quadVerts, texCoords);
SetViewportAndScissor();
FBO_FastBlit(tr.quarterFbo[1], NULL, NULL, NULL, GL_COLOR_BUFFER_BIT, GL_LINEAR);
FBO_Bind(NULL);
}
#endif
if (0 && r_sunlightMode->integer)
{
ivec4_t dstBox;
VectorSet4(dstBox, 0, 0, 128, 128);
FBO_BlitFromTexture(tr.sunShadowDepthImage[0], NULL, NULL, NULL, dstBox, NULL, NULL, 0);
VectorSet4(dstBox, 128, 0, 128, 128);
FBO_BlitFromTexture(tr.sunShadowDepthImage[1], NULL, NULL, NULL, dstBox, NULL, NULL, 0);
VectorSet4(dstBox, 256, 0, 128, 128);
FBO_BlitFromTexture(tr.sunShadowDepthImage[2], NULL, NULL, NULL, dstBox, NULL, NULL, 0);
VectorSet4(dstBox, 384, 0, 128, 128);
FBO_BlitFromTexture(tr.sunShadowDepthImage[3], NULL, NULL, NULL, dstBox, NULL, NULL, 0);
}
if (0)
{
ivec4_t dstBox;
VectorSet4(dstBox, 256, glConfig.vidHeight - 256, 256, 256);
FBO_BlitFromTexture(tr.renderDepthImage, NULL, NULL, NULL, dstBox, NULL, NULL, 0);
VectorSet4(dstBox, 512, glConfig.vidHeight - 256, 256, 256);
FBO_BlitFromTexture(tr.screenShadowImage, NULL, NULL, NULL, dstBox, NULL, NULL, 0);
}
if (0)
{
ivec4_t dstBox;
VectorSet4(dstBox, 256, glConfig.vidHeight - 256, 256, 256);
FBO_BlitFromTexture(tr.sunRaysImage, NULL, NULL, NULL, dstBox, NULL, NULL, 0);
}
#if 0
if (r_cubeMapping->integer && tr.numCubemaps)
{
ivec4_t dstBox;
int cubemapIndex = R_CubemapForPoint( backEnd.viewParms.or.origin );
if (cubemapIndex)
{
VectorSet4(dstBox, 0, glConfig.vidHeight - 256, 256, 256);
//FBO_BlitFromTexture(tr.renderCubeImage, NULL, NULL, NULL, dstBox, &tr.testcubeShader, NULL, 0);
FBO_BlitFromTexture(tr.cubemaps[cubemapIndex - 1].image, NULL, NULL, NULL, dstBox, &tr.testcubeShader, NULL, 0);
}
}
#endif
backEnd.framePostProcessed = qtrue;
return (const void *)(cmd + 1);
}
void FBO_BlitFromTexture(struct image_s *src, vec4_t inSrcTexCorners, vec2_t inSrcTexScale, FBO_t *dst, ivec4_t inDstBox, struct shaderProgram_s *shaderProgram, vec4_t inColor, int blend)
{
ivec4_t dstBox;
vec4_t color;
vec4_t quadVerts[4];
vec2_t texCoords[4];
vec2_t invTexRes;
FBO_t *oldFbo = glState.currentFBO;
mat4_t projection;
int width, height;
if (!src)
{
ri.Printf(PRINT_WARNING, "Tried to blit from a NULL texture!\n");
return;
}
width = dst ? dst->width : glConfig.vidWidth;
height = dst ? dst->height : glConfig.vidHeight;
if (inSrcTexCorners)
{
VectorSet2(texCoords[0], inSrcTexCorners[0], inSrcTexCorners[1]);
VectorSet2(texCoords[1], inSrcTexCorners[2], inSrcTexCorners[1]);
VectorSet2(texCoords[2], inSrcTexCorners[2], inSrcTexCorners[3]);
VectorSet2(texCoords[3], inSrcTexCorners[0], inSrcTexCorners[3]);
}
else
{
VectorSet2(texCoords[0], 0.0f, 1.0f);
VectorSet2(texCoords[1], 1.0f, 1.0f);
VectorSet2(texCoords[2], 1.0f, 0.0f);
VectorSet2(texCoords[3], 0.0f, 0.0f);
}
// framebuffers are 0 bottom, Y up.
if (inDstBox)
{
dstBox[0] = inDstBox[0];
dstBox[1] = height - inDstBox[1] - inDstBox[3];
dstBox[2] = inDstBox[0] + inDstBox[2];
dstBox[3] = height - inDstBox[1];
}
else
{
VectorSet4(dstBox, 0, height, width, 0);
}
if (inSrcTexScale)
{
VectorCopy2(inSrcTexScale, invTexRes);
}
else
{
VectorSet2(invTexRes, 1.0f, 1.0f);
}
if (inColor)
{
VectorCopy4(inColor, color);
}
else
{
VectorCopy4(colorWhite, color);
}
if (!shaderProgram)
{
shaderProgram = &tr.textureColorShader;
}
FBO_Bind(dst);
qglViewport( 0, 0, width, height );
qglScissor( 0, 0, width, height );
Mat4Ortho(0, width, height, 0, 0, 1, projection);
GL_Cull( CT_TWO_SIDED );
GL_BindToTMU(src, TB_COLORMAP);
VectorSet4(quadVerts[0], dstBox[0], dstBox[1], 0.0f, 1.0f);
VectorSet4(quadVerts[1], dstBox[2], dstBox[1], 0.0f, 1.0f);
VectorSet4(quadVerts[2], dstBox[2], dstBox[3], 0.0f, 1.0f);
VectorSet4(quadVerts[3], dstBox[0], dstBox[3], 0.0f, 1.0f);
invTexRes[0] /= src->width;
invTexRes[1] /= src->height;
GL_State( blend );
GLSL_BindProgram(shaderProgram);
GLSL_SetUniformMat4(shaderProgram, UNIFORM_MODELVIEWPROJECTIONMATRIX, projection);
GLSL_SetUniformVec4(shaderProgram, UNIFORM_COLOR, color);
GLSL_SetUniformVec2(shaderProgram, UNIFORM_INVTEXRES, invTexRes);
GLSL_SetUniformVec2(shaderProgram, UNIFORM_AUTOEXPOSUREMINMAX, tr.refdef.autoExposureMinMax);
GLSL_SetUniformVec3(shaderProgram, UNIFORM_TONEMINAVGMAXLINEAR, tr.refdef.toneMinAvgMaxLinear);
RB_InstantQuad2(quadVerts, texCoords);
FBO_Bind(oldFbo);
}
/*
=================
R_Bloom_GeneratexDiamonds
=================
*/
static void R_Bloom_GeneratexDiamonds( void )
{
int i, j, k;
float intensity, scale, *diamond;
// set up sample size workspace
qglScissor( 0, 0, sample_width, sample_height );
qglViewport( 0, 0, sample_width, sample_height );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, sample_width, sample_height, 0, -10, 100 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
// copy small scene into r_bloomeffecttexture
GL_Bind( 0, r_bloomeffecttexture );
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height );
// start modifying the small scene corner
qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
// darkening passes
if( r_bloom_darken->integer )
{
GL_TexEnv( GL_MODULATE );
GL_SetState( GLSTATE_NO_DEPTH_TEST|GLSTATE_SRCBLEND_DST_COLOR|GLSTATE_DSTBLEND_ZERO );
for( i = 0; i < r_bloom_darken->integer; i++ )
R_Bloom_SamplePass( 0, 0 );
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height );
}
// bluring passes
GL_SetState( GLSTATE_NO_DEPTH_TEST|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR );
if( r_bloom_diamond_size->integer > 7 || r_bloom_diamond_size->integer <= 3 )
{
if( r_bloom_diamond_size->integer != 8 )
Cvar_ForceSet( "r_bloom_diamond_size", "8" );
}
else if( r_bloom_diamond_size->integer > 5 )
{
if( r_bloom_diamond_size->integer != 6 )
Cvar_ForceSet( "r_bloom_diamond_size", "6" );
}
else if( r_bloom_diamond_size->integer > 3 )
{
if( r_bloom_diamond_size->integer != 4 )
Cvar_ForceSet( "r_bloom_diamond_size", "4" );
}
switch( r_bloom_diamond_size->integer )
{
case 4:
k = 2;
diamond = &Diamond4x[0][0];
scale = r_bloom_intensity->value * 0.8f;
break;
case 6:
k = 3;
diamond = &Diamond6x[0][0];
scale = r_bloom_intensity->value * 0.5f;
break;
default:
// case 8:
k = 4;
diamond = &Diamond8x[0][0];
scale = r_bloom_intensity->value * 0.3f;
break;
}
for( i = 0; i < r_bloom_diamond_size->integer; i++ )
{
for( j = 0; j < r_bloom_diamond_size->integer; j++, diamond++ )
{
intensity = *diamond * scale;
if( intensity < 0.01f )
continue;
qglColor4f( intensity, intensity, intensity, 1.0 );
R_Bloom_SamplePass( i - k, j - k );
}
}
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, sample_width, sample_height );
// restore full screen workspace
qglScissor( 0, 0, glState.width, glState.height );
qglViewport( 0, 0, glState.width, glState.height );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, glState.width, glState.height, 0, -10, 100 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
}
/*
=============
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;
// clear the z buffer, set the modelview, etc
RB_BeginDrawingView ();
if (glRefConfig.framebufferObject && (backEnd.viewParms.flags & VPF_DEPTHCLAMP) && glRefConfig.depthClamp)
{
qglEnable(GL_DEPTH_CLAMP);
}
if (glRefConfig.framebufferObject && !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL) && (r_depthPrepass->integer || (backEnd.viewParms.flags & VPF_DEPTHSHADOW)))
{
FBO_t *oldFbo = glState.currentFBO;
backEnd.depthFill = qtrue;
qglColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
qglColorMask(!backEnd.colorMask[0], !backEnd.colorMask[1], !backEnd.colorMask[2], !backEnd.colorMask[3]);
backEnd.depthFill = qfalse;
if (tr.msaaResolveFbo)
{
// If we're using multisampling, resolve the depth first
FBO_FastBlit(tr.renderFbo, NULL, tr.msaaResolveFbo, NULL, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
}
else if (tr.renderFbo == NULL)
{
// If we're rendering directly to the screen, copy the depth to a texture
GL_BindToTMU(tr.renderDepthImage, 0);
qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 0, 0, glConfig.vidWidth, glConfig.vidHeight, 0);
}
if (r_ssao->integer)
{
// need the depth in a texture we can do GL_LINEAR sampling on, so copy it to an HDR image
FBO_BlitFromTexture(tr.renderDepthImage, NULL, NULL, tr.hdrDepthFbo, NULL, NULL, NULL, 0);
}
if (r_sunlightMode->integer && backEnd.viewParms.flags & VPF_USESUNLIGHT)
{
vec4_t quadVerts[4];
vec2_t texCoords[4];
vec4_t box;
FBO_Bind(tr.screenShadowFbo);
box[0] = backEnd.viewParms.viewportX * tr.screenShadowFbo->width / (float)glConfig.vidWidth;
box[1] = backEnd.viewParms.viewportY * tr.screenShadowFbo->height / (float)glConfig.vidHeight;
box[2] = backEnd.viewParms.viewportWidth * tr.screenShadowFbo->width / (float)glConfig.vidWidth;
box[3] = backEnd.viewParms.viewportHeight * tr.screenShadowFbo->height / (float)glConfig.vidHeight;
qglViewport(box[0], box[1], box[2], box[3]);
qglScissor(box[0], box[1], box[2], box[3]);
box[0] = backEnd.viewParms.viewportX / (float)glConfig.vidWidth;
box[1] = backEnd.viewParms.viewportY / (float)glConfig.vidHeight;
box[2] = box[0] + backEnd.viewParms.viewportWidth / (float)glConfig.vidWidth;
box[3] = box[1] + backEnd.viewParms.viewportHeight / (float)glConfig.vidHeight;
texCoords[0][0] = box[0]; texCoords[0][1] = box[3];
texCoords[1][0] = box[2]; texCoords[1][1] = box[3];
texCoords[2][0] = box[2]; texCoords[2][1] = box[1];
texCoords[3][0] = box[0]; texCoords[3][1] = box[1];
box[0] = -1.0f;
box[1] = -1.0f;
box[2] = 1.0f;
box[3] = 1.0f;
VectorSet4(quadVerts[0], box[0], box[3], 0, 1);
VectorSet4(quadVerts[1], box[2], box[3], 0, 1);
VectorSet4(quadVerts[2], box[2], box[1], 0, 1);
VectorSet4(quadVerts[3], box[0], box[1], 0, 1);
GL_State( GLS_DEPTHTEST_DISABLE );
GLSL_BindProgram(&tr.shadowmaskShader);
GL_BindToTMU(tr.renderDepthImage, TB_COLORMAP);
if (r_shadowCascadeZFar->integer != 0)
{
GL_BindToTMU(tr.sunShadowDepthImage[0], TB_SHADOWMAP);
GL_BindToTMU(tr.sunShadowDepthImage[1], TB_SHADOWMAP2);
GL_BindToTMU(tr.sunShadowDepthImage[2], TB_SHADOWMAP3);
GL_BindToTMU(tr.sunShadowDepthImage[3], TB_SHADOWMAP4);
GLSL_SetUniformMat4(&tr.shadowmaskShader, UNIFORM_SHADOWMVP, backEnd.refdef.sunShadowMvp[0]);
GLSL_SetUniformMat4(&tr.shadowmaskShader, UNIFORM_SHADOWMVP2, backEnd.refdef.sunShadowMvp[1]);
GLSL_SetUniformMat4(&tr.shadowmaskShader, UNIFORM_SHADOWMVP3, backEnd.refdef.sunShadowMvp[2]);
GLSL_SetUniformMat4(&tr.shadowmaskShader, UNIFORM_SHADOWMVP4, backEnd.refdef.sunShadowMvp[3]);
}
else
{
GL_BindToTMU(tr.sunShadowDepthImage[3], TB_SHADOWMAP);
GLSL_SetUniformMat4(&tr.shadowmaskShader, UNIFORM_SHADOWMVP, backEnd.refdef.sunShadowMvp[3]);
}
GLSL_SetUniformVec3(&tr.shadowmaskShader, UNIFORM_VIEWORIGIN, backEnd.refdef.vieworg);
{
vec4_t viewInfo;
vec3_t viewVector;
float zmax = backEnd.viewParms.zFar;
float ymax = zmax * tan(backEnd.viewParms.fovY * M_PI / 360.0f);
float xmax = zmax * tan(backEnd.viewParms.fovX * M_PI / 360.0f);
float zmin = r_znear->value;
VectorScale(backEnd.refdef.viewaxis[0], zmax, viewVector);
GLSL_SetUniformVec3(&tr.shadowmaskShader, UNIFORM_VIEWFORWARD, viewVector);
VectorScale(backEnd.refdef.viewaxis[1], xmax, viewVector);
GLSL_SetUniformVec3(&tr.shadowmaskShader, UNIFORM_VIEWLEFT, viewVector);
VectorScale(backEnd.refdef.viewaxis[2], ymax, viewVector);
GLSL_SetUniformVec3(&tr.shadowmaskShader, UNIFORM_VIEWUP, viewVector);
VectorSet4(viewInfo, zmax / zmin, zmax, 0.0, 0.0);
GLSL_SetUniformVec4(&tr.shadowmaskShader, UNIFORM_VIEWINFO, viewInfo);
}
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes);
}
if (r_ssao->integer)
{
vec4_t quadVerts[4];
vec2_t texCoords[4];
FBO_Bind(tr.quarterFbo[0]);
qglViewport(0, 0, tr.quarterFbo[0]->width, tr.quarterFbo[0]->height);
qglScissor(0, 0, tr.quarterFbo[0]->width, tr.quarterFbo[0]->height);
VectorSet4(quadVerts[0], -1, 1, 0, 1);
VectorSet4(quadVerts[1], 1, 1, 0, 1);
VectorSet4(quadVerts[2], 1, -1, 0, 1);
VectorSet4(quadVerts[3], -1, -1, 0, 1);
texCoords[0][0] = 0; texCoords[0][1] = 1;
texCoords[1][0] = 1; texCoords[1][1] = 1;
texCoords[2][0] = 1; texCoords[2][1] = 0;
texCoords[3][0] = 0; texCoords[3][1] = 0;
GL_State( GLS_DEPTHTEST_DISABLE );
GLSL_BindProgram(&tr.ssaoShader);
GL_BindToTMU(tr.hdrDepthImage, TB_COLORMAP);
{
vec4_t viewInfo;
float zmax = backEnd.viewParms.zFar;
float zmin = r_znear->value;
VectorSet4(viewInfo, zmax / zmin, zmax, 0.0, 0.0);
GLSL_SetUniformVec4(&tr.ssaoShader, UNIFORM_VIEWINFO, viewInfo);
}
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes);
FBO_Bind(tr.quarterFbo[1]);
qglViewport(0, 0, tr.quarterFbo[1]->width, tr.quarterFbo[1]->height);
qglScissor(0, 0, tr.quarterFbo[1]->width, tr.quarterFbo[1]->height);
GLSL_BindProgram(&tr.depthBlurShader[0]);
GL_BindToTMU(tr.quarterImage[0], TB_COLORMAP);
GL_BindToTMU(tr.hdrDepthImage, TB_LIGHTMAP);
{
vec4_t viewInfo;
float zmax = backEnd.viewParms.zFar;
float zmin = r_znear->value;
VectorSet4(viewInfo, zmax / zmin, zmax, 0.0, 0.0);
GLSL_SetUniformVec4(&tr.depthBlurShader[0], UNIFORM_VIEWINFO, viewInfo);
}
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes);
FBO_Bind(tr.screenSsaoFbo);
qglViewport(0, 0, tr.screenSsaoFbo->width, tr.screenSsaoFbo->height);
qglScissor(0, 0, tr.screenSsaoFbo->width, tr.screenSsaoFbo->height);
GLSL_BindProgram(&tr.depthBlurShader[1]);
GL_BindToTMU(tr.quarterImage[1], TB_COLORMAP);
GL_BindToTMU(tr.hdrDepthImage, TB_LIGHTMAP);
{
vec4_t viewInfo;
float zmax = backEnd.viewParms.zFar;
float zmin = r_znear->value;
VectorSet4(viewInfo, zmax / zmin, zmax, 0.0, 0.0);
GLSL_SetUniformVec4(&tr.depthBlurShader[1], UNIFORM_VIEWINFO, viewInfo);
}
RB_InstantQuad2(quadVerts, texCoords); //, color, shaderProgram, invTexRes);
}
// reset viewport and scissor
FBO_Bind(oldFbo);
SetViewportAndScissor();
}
if (glRefConfig.framebufferObject && (backEnd.viewParms.flags & VPF_DEPTHCLAMP) && glRefConfig.depthClamp)
{
qglDisable(GL_DEPTH_CLAMP);
}
if (!(backEnd.viewParms.flags & VPF_DEPTHSHADOW))
{
RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
if (r_drawSun->integer)
{
RB_DrawSun(0.1, tr.sunShader);
}
if (r_drawSunRays->integer)
{
FBO_t *oldFbo = glState.currentFBO;
FBO_Bind(tr.sunRaysFbo);
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
qglClear( GL_COLOR_BUFFER_BIT );
if (glRefConfig.occlusionQuery)
{
tr.sunFlareQueryActive[tr.sunFlareQueryIndex] = qtrue;
qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, tr.sunFlareQuery[tr.sunFlareQueryIndex]);
}
RB_DrawSun(0.3, tr.sunFlareShader);
if (glRefConfig.occlusionQuery)
{
qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
}
FBO_Bind(oldFbo);
}
// darken down any stencil shadows
RB_ShadowFinish();
// add light flares on lights that aren't obscured
RB_RenderFlares();
}
if (glRefConfig.framebufferObject && tr.renderCubeFbo && backEnd.viewParms.targetFbo == tr.renderCubeFbo)
{
FBO_Bind(NULL);
GL_SelectTexture(TB_CUBEMAP);
GL_BindToTMU(tr.cubemaps[backEnd.viewParms.targetFboCubemapIndex], TB_CUBEMAP);
qglGenerateMipmapEXT(GL_TEXTURE_CUBE_MAP);
GL_SelectTexture(0);
}
return (const void *)(cmd + 1);
}
/*
* RB_Viewport
*/
void RB_Viewport( int x, int y, int w, int h )
{
qglViewport( x, glConfig.height - h - y, w, h );
}
/*
=================
R_BloomBlend
=================
*/
void R_BloomBlend( const refdef_t *fd )
{
if( !( fd->rdflags & RDF_BLOOM ) || !r_bloom->integer )
return;
if( !BLOOM_SIZE )
R_Bloom_InitTextures();
if( screen_texture_width < BLOOM_SIZE || screen_texture_height < BLOOM_SIZE )
return;
// set up full screen workspace
qglScissor( 0, 0, glState.width, glState.height );
qglViewport( 0, 0, glState.width, glState.height );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, glState.width, glState.height, 0, -10, 100 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
GL_Cull( 0 );
GL_SetState( GLSTATE_NO_DEPTH_TEST );
qglColor4f( 1, 1, 1, 1 );
// set up current sizes
curView_x = fd->x;
curView_y = fd->y;
curView_width = fd->width;
curView_height = fd->height;
screenTex_tcw = ( (float)curView_width / (float)screen_texture_width );
screenTex_tch = ( (float)curView_height / (float)screen_texture_height );
if( curView_height > curView_width )
{
sampleText_tcw = ( (float)curView_width / (float)curView_height );
sampleText_tch = 1.0f;
}
else
{
sampleText_tcw = 1.0f;
sampleText_tch = ( (float)curView_height / (float)curView_width );
}
sample_width = ( BLOOM_SIZE * sampleText_tcw );
sample_height = ( BLOOM_SIZE * sampleText_tch );
// copy the screen space we'll use to work into the backup texture
GL_Bind( 0, r_bloombackuptexture );
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, r_screenbackuptexture_width, r_screenbackuptexture_height );
// create the bloom image
R_Bloom_DownsampleView();
R_Bloom_GeneratexDiamonds();
// restore the screen-backup to the screen
GL_SetState( GLSTATE_NO_DEPTH_TEST );
GL_Bind( 0, r_bloombackuptexture );
qglColor4f( 1, 1, 1, 1 );
R_Bloom_Quad( 0, 0, r_screenbackuptexture_width, r_screenbackuptexture_height, 1.0f, 1.0f );
qglScissor( ri.scissor[0], ri.scissor[1], ri.scissor[2], ri.scissor[3] );
R_Bloom_DrawEffect();
qglViewport( ri.viewport[0], ri.viewport[1], ri.viewport[2], ri.viewport[3] );
}
