/*
==============
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." );
}
/*
====================
RE_BeginFrame
If running in stereo, RE_BeginFrame will be called twice
for each RE_EndFrame
====================
*/
void RE_BeginFrame( stereoFrame_t stereoFrame ) {
drawBufferCommand_t *cmd = NULL;
#ifndef IOS
colorMaskCommand_t *colcmd = NULL;
#endif
if ( !tr.registered ) {
return;
}
glState.finishCalled = qfalse;
tr.frameCount++;
tr.frameSceneNum = 0;
#ifdef IOS
GLimp_AcquireGL();
#endif // IOS
//
// do overdraw measurement
//
if ( r_measureOverdraw->integer )
{
if ( glConfig.stencilBits < 4 )
{
ri.Printf( PRINT_ALL, "Warning: not enough stencil bits to measure overdraw: %d\n", glConfig.stencilBits );
ri.Cvar_Set( "r_measureOverdraw", "0" );
r_measureOverdraw->modified = qfalse;
}
else if ( r_shadows->integer == 2 )
{
ri.Printf( PRINT_ALL, "Warning: stencil shadows and overdraw measurement are mutually exclusive\n" );
ri.Cvar_Set( "r_measureOverdraw", "0" );
r_measureOverdraw->modified = qfalse;
}
else
{
R_IssuePendingRenderCommands();
qglEnable( GL_STENCIL_TEST );
qglStencilMask( ~0U );
qglClearStencil( 0U );
qglStencilFunc( GL_ALWAYS, 0U, ~0U );
qglStencilOp( GL_KEEP, GL_INCR, GL_INCR );
}
r_measureOverdraw->modified = qfalse;
}
else
{
// this is only reached if it was on and is now off
if ( r_measureOverdraw->modified ) {
R_IssuePendingRenderCommands();
qglDisable( GL_STENCIL_TEST );
}
r_measureOverdraw->modified = qfalse;
}
//
// texturemode stuff
//
if ( r_textureMode->modified ) {
R_IssuePendingRenderCommands();
GL_TextureMode( r_textureMode->string );
r_textureMode->modified = qfalse;
}
//
// gamma stuff
//
if ( r_gamma->modified ) {
r_gamma->modified = qfalse;
R_IssuePendingRenderCommands();
R_SetColorMappings();
}
// check for errors
if ( !r_ignoreGLErrors->integer )
{
int err;
R_IssuePendingRenderCommands();
if ((err = qglGetError()) != GL_NO_ERROR)
ri.Error(ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!", err);
}
#ifndef IOS
if (glConfig.stereoEnabled) {
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
return;
cmd->commandId = RC_DRAW_BUFFER;
if ( stereoFrame == STEREO_LEFT ) {
cmd->buffer = (int)GL_BACK_LEFT;
} else if ( stereoFrame == STEREO_RIGHT ) {
cmd->buffer = (int)GL_BACK_RIGHT;
} else {
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
}
}
else
#endif
{
#ifndef IOS
if(r_anaglyphMode->integer)
{
if(r_anaglyphMode->modified)
{
// clear both, front and backbuffer.
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
qglClearColor(0.0f, 0.0f, 0.0f, 1.0f);
qglDrawBuffer(GL_FRONT);
qglClear(GL_COLOR_BUFFER_BIT);
qglDrawBuffer(GL_BACK);
qglClear(GL_COLOR_BUFFER_BIT);
r_anaglyphMode->modified = qfalse;
}
if(stereoFrame == STEREO_LEFT)
{
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
return;
if( !(colcmd = R_GetCommandBuffer(sizeof(*colcmd))) )
return;
}
else if(stereoFrame == STEREO_RIGHT)
{
clearDepthCommand_t *cldcmd;
if( !(cldcmd = R_GetCommandBuffer(sizeof(*cldcmd))) )
return;
cldcmd->commandId = RC_CLEARDEPTH;
if( !(colcmd = R_GetCommandBuffer(sizeof(*colcmd))) )
return;
}
else
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
R_SetColorMode(colcmd->rgba, stereoFrame, r_anaglyphMode->integer);
colcmd->commandId = RC_COLORMASK;
}
else
#endif
{
if(stereoFrame != STEREO_CENTER)
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is disabled, but stereoFrame was %i", stereoFrame );
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
return;
}
if(cmd)
{
cmd->commandId = RC_DRAW_BUFFER;
if(r_anaglyphMode->modified)
{
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
r_anaglyphMode->modified = qfalse;
}
if (!Q_stricmp(r_drawBuffer->string, "GL_FRONT"))
cmd->buffer = (int)GL_FRONT;
else
cmd->buffer = (int)GL_BACK;
}
}
tr.refdef.stereoFrame = stereoFrame;
}
void LedsSimulator::setBackColor(QColor color)
{
qglClearColor(color);
updateGL();
}
void GLBox::initializeGL()
{
qglClearColor(Qt::black); // Let OpenGL clear to black
object = makeObject(); // Generate an OpenGL display list
glShadeModel( GL_FLAT );
}
void GLWidget3D::render() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PASS 1: Render to texture
glUseProgram(renderManager.programs["pass1"]);
glBindFramebuffer(GL_FRAMEBUFFER, renderManager.fragDataFB);
glClearColor(0.95, 0.95, 0.95, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderManager.fragDataTex[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, renderManager.fragDataTex[1], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, renderManager.fragDataTex[2], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D, renderManager.fragDataTex[3], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderManager.fragDepthTex, 0);
// Set the list of draw buffers.
GLenum DrawBuffers[4] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
glDrawBuffers(4, DrawBuffers); // "3" is the size of DrawBuffers
// Always check that our framebuffer is ok
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("+ERROR: GL_FRAMEBUFFER_COMPLETE false\n");
exit(0);
}
glUniformMatrix4fv(glGetUniformLocation(renderManager.programs["pass1"], "mvpMatrix"), 1, false, &camera.mvpMatrix[0][0]);
glUniform3f(glGetUniformLocation(renderManager.programs["pass1"], "lightDir"), light_dir.x, light_dir.y, light_dir.z);
glUniformMatrix4fv(glGetUniformLocation(renderManager.programs["pass1"], "light_mvpMatrix"), 1, false, &light_mvpMatrix[0][0]);
glUniform1i(glGetUniformLocation(renderManager.programs["pass1"], "shadowMap"), 6);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D, renderManager.shadow.textureDepth);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
drawScene();
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PASS 2: Create AO
if (renderManager.renderingMode == RenderManager::RENDERING_MODE_SSAO) {
glUseProgram(renderManager.programs["ssao"]);
glBindFramebuffer(GL_FRAMEBUFFER, renderManager.fragDataFB_AO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderManager.fragAOTex, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderManager.fragDepthTex_AO, 0);
GLenum DrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, DrawBuffers); // "1" is the size of DrawBuffers
glClearColor(1, 1, 1, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Always check that our framebuffer is ok
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("++ERROR: GL_FRAMEBUFFER_COMPLETE false\n");
exit(0);
}
glDisable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glUniform2f(glGetUniformLocation(renderManager.programs["ssao"], "pixelSize"), 2.0f / this->width(), 2.0f / this->height());
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "tex0"), 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[0]);
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "tex1"), 2);
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[1]);
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "tex2"), 3);
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[2]);
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "depthTex"), 8);
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDepthTex);
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "noiseTex"), 7);
glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragNoiseTex);
{
glUniformMatrix4fv(glGetUniformLocation(renderManager.programs["ssao"], "mvpMatrix"), 1, false, &camera.mvpMatrix[0][0]);
glUniformMatrix4fv(glGetUniformLocation(renderManager.programs["ssao"], "pMatrix"), 1, false, &camera.pMatrix[0][0]);
}
glUniform1i(glGetUniformLocation(renderManager.programs["ssao"], "uKernelSize"), renderManager.uKernelSize);
glUniform3fv(glGetUniformLocation(renderManager.programs["ssao"], "uKernelOffsets"), renderManager.uKernelOffsets.size(), (const GLfloat*)renderManager.uKernelOffsets.data());
glUniform1f(glGetUniformLocation(renderManager.programs["ssao"], "uPower"), renderManager.uPower);
glUniform1f(glGetUniformLocation(renderManager.programs["ssao"], "uRadius"), renderManager.uRadius);
glBindVertexArray(renderManager.secondPassVAO);
glDrawArrays(GL_QUADS, 0, 4);
glBindVertexArray(0);
glDepthFunc(GL_LEQUAL);
}
else if (renderManager.renderingMode == RenderManager::RENDERING_MODE_LINE || renderManager.renderingMode == RenderManager::RENDERING_MODE_HATCHING) {
glUseProgram(renderManager.programs["line"]);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1, 1, 1, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glUniform2f(glGetUniformLocation(renderManager.programs["line"], "pixelSize"), 1.0f / this->width(), 1.0f / this->height());
glUniformMatrix4fv(glGetUniformLocation(renderManager.programs["line"], "pMatrix"), 1, false, &camera.pMatrix[0][0]);
if (renderManager.renderingMode == RenderManager::RENDERING_MODE_LINE) {
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "useHatching"), 0);
}
else {
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "useHatching"), 1);
}
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "tex0"), 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[0]);
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "tex1"), 2);
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[1]);
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "tex2"), 3);
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[2]);
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "tex3"), 4);
glActiveTexture(GL_TEXTURE4);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[3]);
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "depthTex"), 8);
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDepthTex);
glUniform1i(glGetUniformLocation(renderManager.programs["line"], "hatchingTexture"), 5);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_3D, renderManager.hatchingTextures);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glBindVertexArray(renderManager.secondPassVAO);
glDrawArrays(GL_QUADS, 0, 4);
glBindVertexArray(0);
glDepthFunc(GL_LEQUAL);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Blur
if (renderManager.renderingMode != RenderManager::RENDERING_MODE_LINE && renderManager.renderingMode != RenderManager::RENDERING_MODE_HATCHING) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
qglClearColor(QColor(0xFF, 0xFF, 0xFF));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glUseProgram(renderManager.programs["blur"]);
glUniform2f(glGetUniformLocation(renderManager.programs["blur"], "pixelSize"), 2.0f / this->width(), 2.0f / this->height());
//printf("pixelSize loc %d\n", glGetUniformLocation(vboRenderManager.programs["blur"], "pixelSize"));
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "tex0"), 1);//COLOR
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[0]);
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "tex1"), 2);//NORMAL
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[1]);
/*glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "tex2"), 3);
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDataTex[2]);*/
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "depthTex"), 8);
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragDepthTex);
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "tex3"), 4);//AO
glActiveTexture(GL_TEXTURE4);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, renderManager.fragAOTex);
if (renderManager.renderingMode == RenderManager::RENDERING_MODE_SSAO) {
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "ssao_used"), 1); // ssao used
}
else {
glUniform1i(glGetUniformLocation(renderManager.programs["blur"], "ssao_used"), 0); // no ssao
}
glBindVertexArray(renderManager.secondPassVAO);
glDrawArrays(GL_QUADS, 0, 4);
glBindVertexArray(0);
glDepthFunc(GL_LEQUAL);
}
// REMOVE
glActiveTexture(GL_TEXTURE0);
}
/*
=================
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);
}
}
void Game::initializeGL(){
qglClearColor(Qt::gray);
glEnable(GL_POINT_SMOOTH);
glInitNames();
glPushName(0);
}
void UVWidget::paintGL()
{
glPushAttrib( GL_ALL_ATTRIB_BITS );
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
setupViewport( width(), height() );
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
qglClearColor( Options::bgColor() );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glDisable( GL_DEPTH_TEST );
glDepthMask( GL_FALSE );
// draw texture
glPushMatrix();
glLoadIdentity();
glEnable( GL_TEXTURE_2D );
if ( aTextureBlend->isChecked() )
glEnable( GL_BLEND );
else
glDisable( GL_BLEND );
if( !texfile.isEmpty() )
bindTexture( texfile );
else
bindTexture( texsource );
glTranslatef( -0.5f, -0.5f, 0.0f );
glTranslatef( -1.0f, -1.0f, 0.0f );
for( int i = 0; i < 3; i++ )
{
for( int j = 0; j < 3; j++ )
{
if( i == 1 && j == 1 ) {
glColor4f( 0.75f, 0.75f, 0.75f, 1.0f );
}
else {
glColor4f( 0.5f, 0.5f, 0.5f, 1.0f );
}
glDrawArrays( GL_QUADS, 0, 4 );
glTranslatef( 1.0f, 0.0f, 0.0f );
}
glTranslatef( -3.0f, 1.0f, 0.0f );
}
glTranslatef( 1.0f, -2.0f, 0.0f );
glDisable( GL_TEXTURE_2D );
glPopMatrix();
// draw grid
glPushMatrix();
glLoadIdentity();
glEnable( GL_BLEND );
glLineWidth( 0.8f );
glBegin( GL_LINES );
int glGridMinX = qRound( qMin( glViewRect[0], glViewRect[1] ) / glGridD );
int glGridMaxX = qRound( qMax( glViewRect[0], glViewRect[1] ) / glGridD );
int glGridMinY = qRound( qMin( glViewRect[2], glViewRect[3] ) / glGridD );
int glGridMaxY = qRound( qMax( glViewRect[2], glViewRect[3] ) / glGridD );
for( int i = glGridMinX; i < glGridMaxX; i++ )
{
GLdouble glGridPos = glGridD * i;
if( ( i % ( GRIDSEGS * GRIDSEGS ) ) == 0 ) {
glLineWidth( 1.4f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.4f );
}
else if( zoom > ( GRIDSEGS * GRIDSEGS / 2.0 ) ) {
continue;
}
else if( ( i % GRIDSEGS ) == 0 ) {
glLineWidth( 1.2f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.2f );
}
else if( zoom > ( GRIDSEGS / 2.0 ) ) {
continue;
}
else {
glLineWidth( 0.8f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.1f );
}
glVertex2d( glGridPos, glViewRect[2] );
glVertex2d( glGridPos, glViewRect[3] );
}
for( int i = glGridMinY; i < glGridMaxY; i++ )
{
GLdouble glGridPos = glGridD * i;
if( ( i % ( GRIDSEGS * GRIDSEGS ) ) == 0 ) {
glLineWidth( 1.4f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.4f );
}
else if( zoom > ( GRIDSEGS * GRIDSEGS / 2.0 ) ) {
continue;
}
else if( ( i % GRIDSEGS ) == 0 ) {
glLineWidth( 1.2f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.2f );
}
else if( zoom > ( GRIDSEGS / 2.0 ) ) {
continue;
}
else {
glLineWidth( 0.8f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.1f );
}
glVertex2d( glViewRect[0], glGridPos );
glVertex2d( glViewRect[1], glGridPos );
}
glEnd();
glPopMatrix();
drawTexCoords();
glDisable( GL_DEPTH_TEST );
glDepthMask( GL_FALSE );
if( ! selectRect.isNull() )
{
glLoadIdentity();
glHighlightColor();
glBegin( GL_LINE_LOOP );
glVertex( mapToContents( selectRect.topLeft() ) );
glVertex( mapToContents( selectRect.topRight() ) );
glVertex( mapToContents( selectRect.bottomRight() ) );
glVertex( mapToContents( selectRect.bottomLeft() ) );
glEnd();
}
if ( ! selectPoly.isEmpty() )
{
glLoadIdentity();
glHighlightColor();
glBegin( GL_LINE_LOOP );
foreach ( QPoint p, selectPoly )
{
glVertex( mapToContents( p ) );
}
