/*
================
rvGEWorkspace::Render
Renders the workspace to the given DC
================
*/
void rvGEWorkspace::Render ( HDC hdc )
{
int front;
int back;
float scale;
scale = g_ZoomScales[mZoom];
// Switch GL contexts to our dc
if (!qwglMakeCurrent( hdc, win32.hGLRC ))
{
common->Printf("ERROR: wglMakeCurrent failed.. Error:%i\n", qglGetError());
common->Printf("Please restart Q3Radiant if the Map view is not working\n");
return;
}
// Prepare the view and clear it
GL_State( GLS_DEFAULT );
qglViewport(0, 0, mWindowWidth, mWindowHeight );
qglScissor(0, 0, mWindowWidth, mWindowHeight );
qglClearColor ( 0.75f, 0.75f, 0.75f, 0 );
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_CULL_FACE);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Render the workspace below
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
qglOrtho(0,mWindowWidth, mWindowHeight, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
qglColor3f ( mApplication->GetOptions().GetWorkspaceColor()[0], mApplication->GetOptions().GetWorkspaceColor()[1], mApplication->GetOptions().GetWorkspaceColor()[2] );
qglBegin ( GL_QUADS );
qglVertex2f ( mRect.x, mRect.y );
qglVertex2f ( mRect.x + mRect.w, mRect.y );
qglVertex2f ( mRect.x + mRect.w, mRect.y + mRect.h );
qglVertex2f ( mRect.x, mRect.y + mRect.h );
qglEnd ( );
// Prepare the renderSystem view to draw the GUI in
viewDef_t viewDef;
memset ( &viewDef, 0, sizeof(viewDef) );
tr.viewDef = &viewDef;
tr.viewDef->renderView.x = mRect.x;
tr.viewDef->renderView.y = mWindowHeight - mRect.y - mRect.h;
tr.viewDef->renderView.width = mRect.w;
tr.viewDef->renderView.height = mRect.h;
tr.viewDef->scissor.x1 = 0;
tr.viewDef->scissor.y1 = 0;
tr.viewDef->scissor.x2 = mRect.w;
tr.viewDef->scissor.y2 = mRect.h;
tr.viewDef->isEditor = true;
renderSystem->BeginFrame(mWindowWidth, mWindowHeight );
// Draw the gui
mInterface->Redraw ( 0 ); // eventLoop->Milliseconds() );
// We are done using the renderSystem now
renderSystem->EndFrame( &front, &back );
if ( mApplication->GetActiveWorkspace ( ) == this )
{
mApplication->GetStatusBar().SetTriangles ( backEnd.pc.c_drawIndexes/3 );
}
// Prepare the viewport for drawing selections, etc.
GL_State( GLS_DEFAULT );
qglDisable( GL_TEXTURE_CUBE_MAP_EXT );
// qglDisable(GL_BLEND);
qglDisable(GL_CULL_FACE);
qglViewport(0, 0, mWindowWidth, mWindowHeight );
qglScissor(0, 0, mWindowWidth, mWindowHeight );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
qglOrtho(0,mWindowWidth, mWindowHeight, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
RenderGrid ( );
mSelections.Render ( );
qglFinish ( );
qwglSwapBuffers(hdc);
qglEnable( GL_TEXTURE_CUBE_MAP_EXT );
qglEnable( GL_CULL_FACE);
}
/*
==================
RB_RenderFlares
Because flares are simulating an occular effect, they should be drawn after
everything (all views) in the entire frame has been drawn.
Because of the way portals use the depth buffer to mark off areas, the
needed information would be lost after each view, so we are forced to draw
flares after each view.
The resulting artifact is that flares in mirrors or portals don't dim properly
when occluded by something in the main view, and portal flares that should
extend past the portal edge will be overwritten.
==================
*/
void RB_RenderFlares (void) {
flare_t *f;
flare_t **prev;
qboolean draw;
if ( !r_flares->integer ) {
return;
}
if(r_flareCoeff->modified)
{
if(r_flareCoeff->value == 0.0f)
flareCoeff = atof(FLARE_STDCOEFF);
else
flareCoeff = r_flareCoeff->value;
r_flareCoeff->modified = qfalse;
}
// Reset currentEntity to world so that any previously referenced entities
// don't have influence on the rendering of these flares (i.e. RF_ renderer flags).
backEnd.currentEntity = &tr.worldEntity;
backEnd.or = backEnd.viewParms.world;
// RB_AddDlightFlares();
// perform z buffer readback on each flare in this view
draw = qfalse;
prev = &r_activeFlares;
while ( ( f = *prev ) != NULL ) {
// throw out any flares that weren't added last frame
if ( f->addedFrame < backEnd.viewParms.frameCount - 1 ) {
*prev = f->next;
f->next = r_inactiveFlares;
r_inactiveFlares = f;
continue;
}
// don't draw any here that aren't from this scene / portal
f->drawIntensity = 0;
if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
&& f->inPortal == backEnd.viewParms.isPortal ) {
RB_TestFlare( f );
if ( f->drawIntensity ) {
draw = qtrue;
} else {
// this flare has completely faded out, so remove it from the chain
*prev = f->next;
f->next = r_inactiveFlares;
r_inactiveFlares = f;
continue;
}
}
prev = &f->next;
}
if ( !draw ) {
return; // none visible
}
if ( backEnd.viewParms.isPortal ) {
qglDisable (GL_CLIP_PLANE0);
}
qglPushMatrix();
qglLoadIdentity();
qglMatrixMode( GL_PROJECTION );
qglPushMatrix();
qglLoadIdentity();
qglOrtho( backEnd.viewParms.viewportX, backEnd.viewParms.viewportX + backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportY, backEnd.viewParms.viewportY + backEnd.viewParms.viewportHeight,
-99999, 99999 );
for ( f = r_activeFlares ; f ; f = f->next ) {
if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
&& f->inPortal == backEnd.viewParms.isPortal
&& f->drawIntensity ) {
RB_RenderFlare( f );
}
}
qglPopMatrix();
qglMatrixMode( GL_MODELVIEW );
qglPopMatrix();
}
/*********
SP_DrawTexture
*********/
void SP_DrawTexture(void* pixels, float width, float height, float vShift)
{
if (!pixels)
{
// Ug. We were not even able to load the error message texture.
return;
}
// Create a texture from the buffered file
GLuint texid;
qglGenTextures(1, &texid);
qglBindTexture(GL_TEXTURE_2D, texid);
qglTexImage2D(GL_TEXTURE_2D, 0, GL_DDS1_EXT, width, height, 0, GL_DDS1_EXT, GL_UNSIGNED_BYTE, pixels);
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 );
// Reset every GL state we've got. Who knows what state
// the renderer could be in when this function gets called.
qglColor3f(1.f, 1.f, 1.f);
#ifdef _XBOX
if(glw_state->isWidescreen)
qglViewport(0, 0, 720, 480);
else
#endif
qglViewport(0, 0, 640, 480);
GLboolean alpha = qglIsEnabled(GL_ALPHA_TEST);
qglDisable(GL_ALPHA_TEST);
GLboolean blend = qglIsEnabled(GL_BLEND);
qglDisable(GL_BLEND);
GLboolean cull = qglIsEnabled(GL_CULL_FACE);
qglDisable(GL_CULL_FACE);
GLboolean depth = qglIsEnabled(GL_DEPTH_TEST);
qglDisable(GL_DEPTH_TEST);
GLboolean fog = qglIsEnabled(GL_FOG);
qglDisable(GL_FOG);
GLboolean lighting = qglIsEnabled(GL_LIGHTING);
qglDisable(GL_LIGHTING);
GLboolean offset = qglIsEnabled(GL_POLYGON_OFFSET_FILL);
qglDisable(GL_POLYGON_OFFSET_FILL);
GLboolean scissor = qglIsEnabled(GL_SCISSOR_TEST);
qglDisable(GL_SCISSOR_TEST);
GLboolean stencil = qglIsEnabled(GL_STENCIL_TEST);
qglDisable(GL_STENCIL_TEST);
GLboolean texture = qglIsEnabled(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_2D);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
#ifdef _XBOX
if(glw_state->isWidescreen)
qglOrtho(0, 720, 0, 480, 0, 1);
else
#endif
qglOrtho(0, 640, 0, 480, 0, 1);
qglMatrixMode(GL_TEXTURE0);
qglLoadIdentity();
qglMatrixMode(GL_TEXTURE1);
qglLoadIdentity();
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
memset(&tess, 0, sizeof(tess));
// Draw the error message
qglBeginFrame();
if (!SP_LicenseDone)
{
// clear the screen if we haven't done the
// license yet...
qglClearColor(0, 0, 0, 1);
qglClear(GL_COLOR_BUFFER_BIT);
}
float x1, x2, y1, y2;
#ifdef _XBOX
if(glw_state->isWidescreen)
{
x1 = 0;
x2 = 720;
y1 = 0;
y2 = 480;
}
else {
#endif
x1 = 0;
x2 = 640;
y1 = 0;
y2 = 480;
#ifdef _XBOX
}
#endif
y1 += vShift;
y2 += vShift;
qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
qglTexCoord2f( 0, 0 );
qglVertex2f(x1, y1);
qglTexCoord2f( 1 , 0 );
qglVertex2f(x2, y1);
qglTexCoord2f( 0, 1 );
qglVertex2f(x1, y2);
qglTexCoord2f( 1, 1 );
qglVertex2f(x2, y2);
qglEnd();
qglEndFrame();
qglFlush();
// Restore (most) of the render states we reset
if (alpha) qglEnable(GL_ALPHA_TEST);
else qglDisable(GL_ALPHA_TEST);
if (blend) qglEnable(GL_BLEND);
else qglDisable(GL_BLEND);
if (cull) qglEnable(GL_CULL_FACE);
else qglDisable(GL_CULL_FACE);
if (depth) qglEnable(GL_DEPTH_TEST);
else qglDisable(GL_DEPTH_TEST);
if (fog) qglEnable(GL_FOG);
else qglDisable(GL_FOG);
if (lighting) qglEnable(GL_LIGHTING);
else qglDisable(GL_LIGHTING);
if (offset) qglEnable(GL_POLYGON_OFFSET_FILL);
else qglDisable(GL_POLYGON_OFFSET_FILL);
if (scissor) qglEnable(GL_SCISSOR_TEST);
else qglDisable(GL_SCISSOR_TEST);
if (stencil) qglEnable(GL_STENCIL_TEST);
else qglDisable(GL_STENCIL_TEST);
if (texture) qglEnable(GL_TEXTURE_2D);
else qglDisable(GL_TEXTURE_2D);
// Kill the texture
qglDeleteTextures(1, &texid);
}
/*
==================
RB_RenderFlares
Because flares are simulating an occular effect, they should be drawn after
everything (all views) in the entire frame has been drawn.
Because of the way portals use the depth buffer to mark off areas, the
needed information would be lost after each view, so we are forced to draw
flares after each view.
The resulting artifact is that flares in mirrors or portals don't dim properly
when occluded by something in the main view, and portal flares that should
extend past the portal edge will be overwritten.
==================
*/
void RB_RenderFlares(void)
{
flare_t *f;
flare_t **prev;
qboolean draw;
if (!r_flares->integer)
{
return;
}
// (SA) turned light flares back on. must evaluate problem id had with this
RB_AddDlightFlares();
RB_AddCoronaFlares();
// perform z buffer readback on each flare in this view
draw = qfalse;
prev = &r_activeFlares;
while ((f = *prev) != NULL)
{
// throw out any flares that weren't added last frame
if (f->addedFrame < backEnd.viewParms.frameCount - 1)
{
*prev = f->next;
f->next = r_inactiveFlares;
r_inactiveFlares = f;
continue;
}
// don't draw any here that aren't from this scene / portal
f->drawIntensity = 0;
if (f->frameSceneNum == backEnd.viewParms.frameSceneNum
&& f->inPortal == backEnd.viewParms.isPortal)
{
RB_TestFlare(f);
if (f->drawIntensity)
{
draw = qtrue;
}
else
{
// this flare has completely faded out, so remove it from the chain
*prev = f->next;
f->next = r_inactiveFlares;
r_inactiveFlares = f;
continue;
}
}
prev = &f->next;
}
if (!draw)
{
return; // none visible
}
if (backEnd.viewParms.isPortal)
{
qglDisable(GL_CLIP_PLANE0);
}
qglPushMatrix();
qglLoadIdentity();
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(backEnd.viewParms.viewportX, backEnd.viewParms.viewportX + backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportY, backEnd.viewParms.viewportY + backEnd.viewParms.viewportHeight,
-99999, 99999);
for (f = r_activeFlares ; f ; f = f->next)
{
if (f->frameSceneNum == backEnd.viewParms.frameSceneNum
&& f->inPortal == backEnd.viewParms.isPortal
&& f->drawIntensity)
{
RB_RenderFlare(f);
}
}
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
}
// Draw the glow blur over the screen additively.
static inline void RB_DrawGlowOverlay()
{
qglDisable (GL_CLIP_PLANE0);
GL_Cull( CT_TWO_SIDED );
// Go into orthographic 2d mode.
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 0, -1, 1);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity();
GL_State(GLS_DEPTHTEST_DISABLE);
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
// For debug purposes.
if ( r_DynamicGlow->integer != 2 )
{
// Render the normal scene texture.
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage );
qglBegin(GL_QUADS);
qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
qglTexCoord2f( 0, glConfig.vidHeight );
qglVertex2f( 0, 0 );
qglTexCoord2f( 0, 0 );
qglVertex2f( 0, glConfig.vidHeight );
qglTexCoord2f( glConfig.vidWidth, 0 );
qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
qglTexCoord2f( glConfig.vidWidth, glConfig.vidHeight );
qglVertex2f( glConfig.vidWidth, 0 );
qglEnd();
}
// One and Inverse Src Color give a very soft addition, while one one is a bit stronger. With one one we can
// use additive blending through multitexture though.
if ( r_DynamicGlowSoft->integer )
{
qglBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_COLOR );
}
else
{
qglBlendFunc( GL_ONE, GL_ONE );
}
qglEnable( GL_BLEND );
// Now additively render the glow texture.
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
qglBegin(GL_QUADS);
qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
qglTexCoord2f( 0, r_DynamicGlowHeight->integer );
qglVertex2f( 0, 0 );
qglTexCoord2f( 0, 0 );
qglVertex2f( 0, glConfig.vidHeight );
qglTexCoord2f( r_DynamicGlowWidth->integer, 0 );
qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
qglTexCoord2f( r_DynamicGlowWidth->integer, r_DynamicGlowHeight->integer );
qglVertex2f( glConfig.vidWidth, 0 );
qglEnd();
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
qglBlendFunc( GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR );
qglDisable( GL_BLEND );
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
}
/*
==============
CZWnd::Z_Draw
==============
*/
void CZWnd::Z_Draw( void ) {
brush_t *brush;
float w, h;
float top, bottom;
idVec3 org_top, org_bottom, dir_up, dir_down;
int xCam = z.width / 3 / z.scale; // sikk - Keep brush widths proportional to window
if ( !active_brushes.next ) {
return; // not valid yet
}
// clear
qglViewport( 0, 0, z.width, z.height );
qglScissor( 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);
*/
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
//
// glbitClear |= GL_DEPTH_BUFFER_BIT;
// qglClear(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 );
globalImages->BindNull();
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_BLEND );
// now draw the grid
Z_DrawGrid();
// draw stuff
qglDisable( GL_CULL_FACE );
qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
globalImages->BindNull();
// 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] = 4096;
VectorCopy( z.origin, org_bottom );
org_bottom[2] = -4096;
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 = declManager->FindMaterial( brush->brush_faces->texdef.name );
qglColor3f( brush->owner->eclass->color.x, brush->owner->eclass->color.y, brush->owner->eclass->color.z );
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 = declManager->FindMaterial( brush->brush_faces->texdef.name );
qglColor3f( brush->owner->eclass->color.x, brush->owner->eclass->color.y, brush->owner->eclass->color.z );
qglBegin( GL_QUADS );
qglVertex2f( -xCam, bottom );
qglVertex2f( xCam, bottom );
qglVertex2f( xCam, top );
qglVertex2f( -xCam, top );
qglEnd();
}
}
}
qglColor3fv( g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES].ToFloatPtr() );
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();
}
Z_DrawCameraIcon();
Z_DrawZClip();
qglFinish();
QE_CheckOpenGLForErrors();
}
static inline void RB_BlurGlowTexture()
{
qglDisable (GL_CLIP_PLANE0);
GL_Cull( CT_TWO_SIDED );
// Go into orthographic 2d mode.
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight, 0, -1, 1);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity();
GL_State(GLS_DEPTHTEST_DISABLE);
/////////////////////////////////////////////////////////
// Setup vertex and pixel programs.
/////////////////////////////////////////////////////////
// NOTE: The 0.25 is because we're blending 4 textures (so = 1.0) and we want a relatively normalized pixel
// intensity distribution, but this won't happen anyways if intensity is higher than 1.0.
float fBlurDistribution = r_DynamicGlowIntensity->value * 0.25f;
float fBlurWeight[4] = { fBlurDistribution, fBlurDistribution, fBlurDistribution, 1.0f };
// Enable and set the Vertex Program.
qglEnable( GL_VERTEX_PROGRAM_ARB );
qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
// Apply Pixel Shaders.
if ( qglCombinerParameterfvNV )
{
BeginPixelShader( GL_REGISTER_COMBINERS_NV, tr.glowPShader );
// Pass the blur weight to the regcom.
qglCombinerParameterfvNV( GL_CONSTANT_COLOR0_NV, (float*)&fBlurWeight );
}
else if ( qglProgramEnvParameter4fARB )
{
BeginPixelShader( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
// Pass the blur weight to the Fragment Program.
qglProgramEnvParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, fBlurWeight[0], fBlurWeight[1], fBlurWeight[2], fBlurWeight[3] );
}
/////////////////////////////////////////////////////////
// Set the blur texture to the 4 texture stages.
/////////////////////////////////////////////////////////
// How much to offset each texel by.
float fTexelWidthOffset = 0.1f, fTexelHeightOffset = 0.1f;
GLuint uiTex = tr.screenGlow;
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
/////////////////////////////////////////////////////////
// Draw the blur passes (each pass blurs it more, increasing the blur radius ).
/////////////////////////////////////////////////////////
//int iTexWidth = backEnd.viewParms.viewportWidth, iTexHeight = backEnd.viewParms.viewportHeight;
int iTexWidth = glConfig.vidWidth, iTexHeight = glConfig.vidHeight;
for ( int iNumBlurPasses = 0; iNumBlurPasses < r_DynamicGlowPasses->integer; iNumBlurPasses++ )
{
// Load the Texel Offsets into the Vertex Program.
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 0, -fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 1, -fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 2, fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 3, fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
// After first pass put the tex coords to the viewport size.
if ( iNumBlurPasses == 1 )
{
if ( !g_bTextureRectangleHack )
{
iTexWidth = backEnd.viewParms.viewportWidth;
iTexHeight = backEnd.viewParms.viewportHeight;
}
uiTex = tr.blurImage;
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
// Copy the current image over.
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
// Draw the fullscreen quad.
qglBegin( GL_QUADS );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, iTexHeight );
qglVertex2f( 0, 0 );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, 0 );
qglVertex2f( 0, backEnd.viewParms.viewportHeight );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, 0 );
qglVertex2f( backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, iTexHeight );
qglVertex2f( backEnd.viewParms.viewportWidth, 0 );
qglEnd();
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
// Increase the texel offsets.
// NOTE: This is possibly the most important input to the effect. Even by using an exponential function I've been able to
// make it look better (at a much higher cost of course). This is cheap though and still looks pretty great. In the future
// I might want to use an actual gaussian equation to correctly calculate the pixel coefficients and attenuates, texel
// offsets, gaussian amplitude and radius...
fTexelWidthOffset += r_DynamicGlowDelta->value;
fTexelHeightOffset += r_DynamicGlowDelta->value;
}
// Disable multi-texturing.
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
qglDisable( GL_VERTEX_PROGRAM_ARB );
EndPixelShader();
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
qglDisable( GL_BLEND );
glState.currenttmu = 0; //this matches the last one we activated
}
/*
=======================================================================================================================
=======================================================================================================================
*/
void CNewTexWnd::OnPaint() {
CPaintDC dc(this); // device context for painting
int nOld = g_qeglobals.d_texturewin.m_nTotalHeight;
//hdcTexture = GetDC();
if (!qwglMakeCurrent(dc.GetSafeHdc(), win32.hGLRC)) {
common->Printf("ERROR: wglMakeCurrent failed..\n ");
}
else {
const char *name;
qglClearColor
(
g_qeglobals.d_savedinfo.colors[COLOR_TEXTUREBACK][0],
g_qeglobals.d_savedinfo.colors[COLOR_TEXTUREBACK][1],
g_qeglobals.d_savedinfo.colors[COLOR_TEXTUREBACK][2],
0
);
qglViewport(0, 0, rectClient.Width(), rectClient.Height());
qglScissor(0, 0, rectClient.Width(), rectClient.Height());
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_BLEND);
qglOrtho(0, rectClient.Width(), origin.y - rectClient.Height(), origin.y, -100, 100);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// init stuff
current.x = 8;
current.y = -8;
currentRow = 0;
currentIndex = 0;
while (1) {
const idMaterial *mat = NextPos();
if (mat == NULL) {
break;
}
int width = mat->GetEditorImage()->uploadWidth * ((float)g_PrefsDlg.m_nTextureScale / 100);
int height = mat->GetEditorImage()->uploadHeight * ((float)g_PrefsDlg.m_nTextureScale / 100);
// Is this texture visible?
if ((draw.y - height - FONT_HEIGHT < origin.y) && (draw.y > origin.y - rectClient.Height())) {
// if in use, draw a background
qglLineWidth(1);
qglColor3f(1, 1, 1);
globalImages->BindNull();
qglBegin(GL_LINE_LOOP);
qglVertex2f(draw.x - 1, draw.y + 1 - FONT_HEIGHT);
qglVertex2f(draw.x - 1, draw.y - height - 1 - FONT_HEIGHT);
qglVertex2f(draw.x + 1 + width, draw.y - height - 1 - FONT_HEIGHT);
qglVertex2f(draw.x + 1 + width, draw.y + 1 - FONT_HEIGHT);
qglEnd();
// Draw the texture
float fScale = (g_PrefsDlg.m_bHiColorTextures == TRUE) ? ((float)g_PrefsDlg.m_nTextureScale / 100) : 1.0;
mat->GetEditorImage()->Bind();
QE_CheckOpenGLForErrors();
qglColor3f(1, 1, 1);
qglBegin(GL_QUADS);
qglTexCoord2f(0, 0);
qglVertex2f(draw.x, draw.y - FONT_HEIGHT);
qglTexCoord2f(1, 0);
qglVertex2f(draw.x + width, draw.y - FONT_HEIGHT);
qglTexCoord2f(1, 1);
qglVertex2f(draw.x + width, draw.y - FONT_HEIGHT - height);
qglTexCoord2f(0, 1);
qglVertex2f(draw.x, draw.y - FONT_HEIGHT - height);
qglEnd();
// draw the selection border
if ( !idStr::Icmp(g_qeglobals.d_texturewin.texdef.name, mat->GetName()) ) {
qglLineWidth(3);
qglColor3f(1, 0, 0);
globalImages->BindNull();
qglBegin(GL_LINE_LOOP);
qglVertex2f(draw.x - 4, draw.y - FONT_HEIGHT + 4);
qglVertex2f(draw.x - 4, draw.y - FONT_HEIGHT - height - 4);
qglVertex2f(draw.x + 4 + width, draw.y - FONT_HEIGHT - height - 4);
qglVertex2f(draw.x + 4 + width, draw.y - FONT_HEIGHT + 4);
qglEnd();
qglLineWidth(1);
}
// draw the texture name
globalImages->BindNull();
qglColor3f(1, 1, 1);
qglRasterPos2f(draw.x, draw.y - FONT_HEIGHT + 2);
// don't draw the directory name
for (name = mat->GetName(); *name && *name != '/' && *name != '\\'; name++) {
;
}
if (!*name) {
name = mat->GetName();
}
else {
name++;
}
qglCallLists(strlen(name), GL_UNSIGNED_BYTE, name);
//qglCallLists(va("%s -- %d, %d" strlen(name), GL_UNSIGNED_BYTE, name);
}
}
g_qeglobals.d_texturewin.m_nTotalHeight = abs(draw.y) + 100;
// reset the current texture
globalImages->BindNull();
qglFinish();
qwglSwapBuffers(dc.GetSafeHdc());
TRACE("Texture Paint\n");
}
if (g_PrefsDlg.m_bTextureScrollbar && (m_bNeedRange || g_qeglobals.d_texturewin.m_nTotalHeight != nOld)) {
m_bNeedRange = false;
SetScrollRange(SB_VERT, 0, g_qeglobals.d_texturewin.m_nTotalHeight, TRUE);
}
//ReleaseDC(hdcTexture);
}
void RB_DistortionFill(void)
{
float alpha = tr_distortionAlpha;
float spost = 0.0f;
float spost2 = 0.0f;
if ( glConfig.stencilBits < 4 )
{
return;
}
//ok, cap the stupid thing now I guess
if (!tr_distortionPrePost)
{
RB_CaptureScreenImage();
}
qglEnable(GL_STENCIL_TEST);
qglStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
qglDisable (GL_CLIP_PLANE0);
GL_Cull( CT_TWO_SIDED );
//reset the view matrices and go into ortho mode
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 32, -1, 1);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity();
if (tr_distortionStretch)
{ //override
spost = tr_distortionStretch;
spost2 = tr_distortionStretch;
}
else
{ //do slow stretchy effect
spost = sin(tr.refdef.time*0.0005f);
if (spost < 0.0f)
{
spost = -spost;
}
spost *= 0.2f;
spost2 = sin(tr.refdef.time*0.0005f);
if (spost2 < 0.0f)
{
spost2 = -spost2;
}
spost2 *= 0.08f;
}
if (alpha != 1.0f)
{ //blend
GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
}
else
{ //be sure to reset the draw state
GL_State(0);
}
qglBegin(GL_QUADS);
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
qglTexCoord2f(0+spost2, 1-spost);
qglVertex2f(0, 0);
qglTexCoord2f(0+spost2, 0+spost);
qglVertex2f(0, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 0+spost);
qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 1-spost);
qglVertex2f(glConfig.vidWidth, 0);
qglEnd();
if (tr_distortionAlpha == 1.0f && tr_distortionStretch == 0.0f)
{ //no overrides
if (tr_distortionNegate)
{ //probably the crazy alternate saber trail
alpha = 0.8f;
GL_State(GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR);
}
else
{
alpha = 0.5f;
GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
}
spost = sin(tr.refdef.time*0.0008f);
if (spost < 0.0f)
{
spost = -spost;
}
spost *= 0.08f;
spost2 = sin(tr.refdef.time*0.0008f);
if (spost2 < 0.0f)
{
spost2 = -spost2;
}
spost2 *= 0.2f;
qglBegin(GL_QUADS);
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
qglTexCoord2f(0+spost2, 1-spost);
qglVertex2f(0, 0);
qglTexCoord2f(0+spost2, 0+spost);
qglVertex2f(0, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 0+spost);
qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 1-spost);
qglVertex2f(glConfig.vidWidth, 0);
qglEnd();
}
//pop the view matrices back
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
qglDisable( GL_STENCIL_TEST );
}
/*
==============
RenderBumpTriangles
==============
*/
static void RenderBumpTriangles( srfTriangles_t *lowMesh, renderBump_t *rb ) {
int i, j;
RB_SetGL2D();
qglDisable( GL_CULL_FACE );
qglColor3f( 1, 1, 1 );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, 1, 1, 0, -1, 1 );
qglDisable( GL_BLEND );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
qglDisable( GL_DEPTH_TEST );
qglClearColor(1,0,0,1);
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
qglColor3f( 1, 1, 1 );
// create smoothed normals for the surface, which might be
// different than the normals at the vertexes if the
// surface uses unsmoothedNormals, which only takes the
// normal from a single triangle. We need properly smoothed
// normals to make sure that the traces always go off normal
// to the true surface.
idVec3 *lowMeshNormals = (idVec3 *)Mem_ClearedAlloc( lowMesh->numVerts * sizeof( *lowMeshNormals ) );
R_DeriveFacePlanes( lowMesh );
R_CreateSilIndexes( lowMesh ); // recreate, merging the mirrored verts back together
const idPlane *planes = lowMesh->facePlanes;
for ( i = 0 ; i < lowMesh->numIndexes ; i += 3, planes++ ) {
for ( j = 0 ; j < 3 ; j++ ) {
int index;
index = lowMesh->silIndexes[i+j];
lowMeshNormals[index] += (*planes).Normal();
}
}
// normalize and replicate from silIndexes to all indexes
for ( i = 0 ; i < lowMesh->numIndexes ; i++ ) {
lowMeshNormals[lowMesh->indexes[i]] = lowMeshNormals[lowMesh->silIndexes[i]];
lowMeshNormals[lowMesh->indexes[i]].Normalize();
}
// rasterize each low poly face
for ( j = 0 ; j < lowMesh->numIndexes ; j+=3 ) {
// pump the event loop so the window can be dragged around
Sys_GenerateEvents();
RasterizeTriangle( lowMesh, lowMeshNormals, j/3, rb );
qglClearColor(1,0,0,1);
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
qglRasterPos2f( 0, 1 );
qglPixelZoom( glConfig.vidWidth / (float)rb->width, glConfig.vidHeight / (float)rb->height );
qglDrawPixels( rb->width, rb->height, GL_RGBA, GL_UNSIGNED_BYTE, rb->localPic );
qglPixelZoom( 1, 1 );
qglFlush();
GLimp_SwapBuffers();
}
Mem_Free( lowMeshNormals );
}
/*
==============
RenderBumpFlat_f
==============
*/
void RenderBumpFlat_f( const idCmdArgs &args ) {
int width, height;
idStr source;
int i;
idBounds bounds;
srfTriangles_t *mesh;
float boundsScale;
// update the screen as we print
common->SetRefreshOnPrint( true );
width = height = 256;
boundsScale = 0;
// check options
for ( i = 1 ; i < args.Argc() - 1; i++ ) {
const char *s;
s = args.Argv( i );
if ( s[0] == '-' ) {
i++;
s = args.Argv( i );
}
if ( !idStr::Icmp( s, "size" ) ) {
if ( i + 2 >= args.Argc() ) {
i = args.Argc();
break;
}
width = atoi( args.Argv( i + 1 ) );
height = atoi( args.Argv( i + 2 ) );
i += 2;
} else {
common->Printf( "WARNING: Unknown option \"%s\"\n", s );
break;
}
}
if ( i != ( args.Argc() - 1 ) ) {
common->Error( "usage: renderBumpFlat [-size width height] asefile" );
}
common->Printf( "Final image size: %i, %i\n", width, height );
// load the source in "fastload" mode, because we don't
// need tangent and shadow information
source = args.Argv( i );
idRenderModel *highPolyModel = renderModelManager->AllocModel();
highPolyModel->PartialInitFromFile( source );
if ( highPolyModel->IsDefaultModel() ) {
common->Error( "failed to load %s", source.c_str() );
}
// combine the high poly model into a single polyset
if ( highPolyModel->NumSurfaces() != 1 ) {
highPolyModel = CombineModelSurfaces( highPolyModel );
}
// create normals if not present in file
const modelSurface_t *surf = highPolyModel->Surface( 0 );
mesh = surf->geometry;
// bound the entire file
R_BoundTriSurf( mesh );
bounds = mesh->bounds;
SaveWindow();
ResizeWindow( width, height );
// for small images, the viewport may be less than the minimum window
qglViewport( 0, 0, width, height );
qglEnable( GL_CULL_FACE );
qglCullFace( GL_FRONT );
qglDisable( GL_STENCIL_TEST );
qglDisable( GL_SCISSOR_TEST );
qglDisable( GL_ALPHA_TEST );
qglDisable( GL_BLEND );
qglEnable( GL_DEPTH_TEST );
qglDisable( GL_TEXTURE_2D );
qglDepthMask( GL_TRUE );
qglDepthFunc( GL_LEQUAL );
qglColor3f( 1, 1, 1 );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( bounds[0][0], bounds[1][0], bounds[0][2],
bounds[1][2], -( bounds[0][1] - 1 ), -( bounds[1][1] + 1 ) );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
// flat maps are automatically anti-aliased
idStr filename;
int j, k, c;
byte *buffer;
int *sumBuffer, *colorSumBuffer;
bool flat;
int sample;
sumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
buffer = (byte *)Mem_Alloc( width * height * 4 );
colorSumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
flat = false;
//flat = true;
for ( sample = 0 ; sample < 16 ; sample++ ) {
float xOff, yOff;
xOff = ( ( sample & 3 ) / 4.0 ) * ( bounds[1][0] - bounds[0][0] ) / width;
yOff = ( ( sample / 4 ) / 4.0 ) * ( bounds[1][2] - bounds[0][2] ) / height;
for ( int colorPass = 0 ; colorPass < 2 ; colorPass++ ) {
qglClearColor(0.5,0.5,0.5,0);
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
qglBegin( GL_TRIANGLES );
for ( i = 0 ; i < highPolyModel->NumSurfaces() ; i++ ) {
const modelSurface_t *surf = highPolyModel->Surface( i );
mesh = surf->geometry;
if ( colorPass ) {
// just render the surface color for artist visualization
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *a;
v = mesh->indexes[j+k];
qglColor3ubv( mesh->verts[v].color );
a = mesh->verts[v].xyz.ToFloatPtr();
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
} else {
// render as normal map
// we can either flat shade from the plane,
// or smooth shade from the vertex normals
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
if ( flat ) {
idPlane plane;
idVec3 *a, *b, *c;
int v1, v2, v3;
v1 = mesh->indexes[j+0];
v2 = mesh->indexes[j+1];
v3 = mesh->indexes[j+2];
a = &mesh->verts[ v1 ].xyz;
b = &mesh->verts[ v2 ].xyz;
c = &mesh->verts[ v3 ].xyz;
plane.FromPoints( *a, *b, *c );
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
qglColor3f( 0.5, 0.5, 0.5 );
} else {
qglColor3f( 0.5 + 0.5*plane[0], 0.5 - 0.5*plane[2], 0.5 - 0.5*plane[1] );
}
qglVertex3f( (*a)[0] + xOff, (*a)[2] + yOff, (*a)[1] );
qglVertex3f( (*b)[0] + xOff, (*b)[2] + yOff, (*b)[1] );
qglVertex3f( (*c)[0] + xOff, (*c)[2] + yOff, (*c)[1] );
} else {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *n;
float *a;
v = mesh->indexes[j+k];
n = mesh->verts[v].normal.ToFloatPtr();
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
qglColor3f( 0.5, 0.5, 0.5 );
} else {
// we are going to flip the normal Z direction
qglColor3f( 0.5 + 0.5*n[0], 0.5 - 0.5*n[2], 0.5 - 0.5*n[1] );
}
a = mesh->verts[v].xyz.ToFloatPtr();
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
}
}
}
qglEnd();
qglFlush();
GLimp_SwapBuffers();
qglReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer );
if ( colorPass ) {
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
colorSumBuffer[i*4+0] += buffer[i*4+0];
colorSumBuffer[i*4+1] += buffer[i*4+1];
colorSumBuffer[i*4+2] += buffer[i*4+2];
colorSumBuffer[i*4+3] += buffer[i*4+3];
}
} else {
// normalize
c = width * height;
for ( i = 0 ; i < c ; i++ ) {
idVec3 v;
v[0] = ( buffer[i*4+0] - 128 ) / 127.0;
v[1] = ( buffer[i*4+1] - 128 ) / 127.0;
v[2] = ( buffer[i*4+2] - 128 ) / 127.0;
v.Normalize();
buffer[i*4+0] = 128 + 127 * v[0];
buffer[i*4+1] = 128 + 127 * v[1];
buffer[i*4+2] = 128 + 127 * v[2];
}
// outline into non-drawn areas
for ( i = 0 ; i < 8 ; i++ ) {
OutlineNormalMap( buffer, width, height, 128, 128, 128 );
}
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
sumBuffer[i*4+0] += buffer[i*4+0];
sumBuffer[i*4+1] += buffer[i*4+1];
sumBuffer[i*4+2] += buffer[i*4+2];
sumBuffer[i*4+3] += buffer[i*4+3];
}
}
}
}
c = width * height;
// save out the color map
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = colorSumBuffer[i*4+0] / 16;
buffer[i*4+1] = colorSumBuffer[i*4+1] / 16;
buffer[i*4+2] = colorSumBuffer[i*4+2] / 16;
buffer[i*4+3] = colorSumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_color.tga" );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// save out the local map
// scale the sum buffer back down to the sample buffer
// we allow this to denormalize
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = sumBuffer[i*4+0] / 16;
buffer[i*4+1] = sumBuffer[i*4+1] / 16;
buffer[i*4+2] = sumBuffer[i*4+2] / 16;
buffer[i*4+3] = sumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_local.tga" );
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// free the model
renderModelManager->FreeModel( highPolyModel );
// free our work buffer
Mem_Free( buffer );
Mem_Free( sumBuffer );
Mem_Free( colorSumBuffer );
RestoreWindow();
// stop updating the screen as we print
common->SetRefreshOnPrint( false );
common->Error( "Completed." );
}