void Terrain_DrawCam( terrainMesh_t *pm ) {
qglColor3f( 1,1,1 );
qglPushAttrib( GL_ALL_ATTRIB_BITS );
if ( g_bPatchWireFrame ) {
if( pm->bSelected ) {
qglLineWidth( 2 );
} else {
qglLineWidth( 1 );
}
qglDisable( GL_CULL_FACE );
qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
qglDisable( GL_TEXTURE_2D );
if ( g_PrefsDlg.m_bGLLighting ) {
qglDisable( GL_LIGHTING );
}
DrawTerrain( pm, pm->bSelected, true );
if ( g_PrefsDlg.m_bGLLighting ) {
qglEnable( GL_LIGHTING );
}
qglEnable( GL_CULL_FACE );
qglLineWidth( 1 );
} else {
qglEnable( GL_CULL_FACE );
qglCullFace( GL_FRONT );
// draw the textured polys
DrawTerrain( pm, pm->bSelected, true );
// if selected, draw the red tint on the polys
if( pm->bSelected ) { // && ( g_qeglobals.d_savedinfo.include & INCLUDE_CAMERATINT ) ) {
qglColor4f( 1.0, 0.0, 0.0, 0.3 );
qglEnable( GL_BLEND );
qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
DrawTerrain( pm, pm->bSelected );
qglColor3f( 1, 1, 1 );
}
// draw the backside poly outlines
qglCullFace( GL_BACK );
qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
qglDisable( GL_BLEND );
DrawTerrain( pm, pm->bSelected, true );
}
qglPopAttrib();
}
void idGLDrawableConsole::draw(int x, int y, int w, int h) {
qglPushAttrib( GL_ALL_ATTRIB_BITS );
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglScissor( 0, 0, w, h );
qglClear( GL_COLOR_BUFFER_BIT );
renderSystem->BeginFrame( w, h );
console->Draw( true );
renderSystem->EndFrame( NULL, NULL );
qglPopAttrib();
}
void Gui_Render()
{
const text_shader_description *shader = renderer.shaderManager->getTextShader();
screenSize[0] = screen_info.w;
screenSize[1] = screen_info.h;
qglUseProgramObjectARB(shader->program);
qglUniform1iARB(shader->sampler, 0);
qglUniform2fvARB(shader->screenSize, 1, screenSize);
qglUniform1fARB(shader->colorReplace, 0.0f);
qglPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
qglPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT | GL_CLIENT_VERTEX_ARRAY_BIT);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglPolygonMode(GL_FRONT, GL_FILL);
qglFrontFace(GL_CCW);
qglEnable(GL_BLEND);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglDisable(GL_ALPHA_TEST);
if(World_GetPlayer() && main_inventory_manager)
{
Gui_DrawInventory(engine_frame_time);
}
Gui_DrawNotifier(engine_frame_time);
qglUseProgramObjectARB(shader->program);
qglDepthMask(GL_FALSE);
qglPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if(screen_info.crosshair != 0)
{
Gui_DrawCrosshair();
}
Gui_DrawBars();
qglUniform1fARB(shader->colorReplace, 1.0f);
GLText_RenderStrings();
Con_Draw(engine_frame_time);
qglUniform1fARB(shader->colorReplace, 0.0f);
qglDepthMask(GL_TRUE);
qglPopClientAttrib();
qglPopAttrib();
}
/*
=================
RB_PolygonClear
This will cover the entire screen with normal rasterization.
Texturing is disabled, but the existing glColor, glDepthMask,
glColorMask, and the enabled state of depth buffering and
stenciling will matter.
=================
*/
void RB_PolygonClear() {
qglPushMatrix();
qglPushAttrib( GL_ALL_ATTRIB_BITS );
qglLoadIdentity();
qglDisable( GL_TEXTURE_2D );
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_SCISSOR_TEST );
qglBegin( GL_POLYGON );
qglVertex3f( -20, -20, -10 );
qglVertex3f( 20, -20, -10 );
qglVertex3f( 20, 20, -10 );
qglVertex3f( -20, 20, -10 );
qglEnd();
qglPopAttrib();
qglPopMatrix();
}
void Gui_DrawLoadScreen(int value)
{
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
qglPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
qglPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
qglEnableClientState(GL_VERTEX_ARRAY);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglEnableClientState(GL_COLOR_ARRAY);
qglDisableClientState(GL_NORMAL_ARRAY);
qglEnable(GL_BLEND);
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_ALPHA_TEST);
qglDepthMask(GL_FALSE);
qglPolygonMode(GL_FRONT, GL_FILL);
qglFrontFace(GL_CCW);
const GLfloat color_w[4] = {1.0f, 1.0f, 1.0f, 1.0f};
const text_shader_description *shader = renderer.shaderManager->getTextShader();
screenSize[0] = screen_info.w;
screenSize[1] = screen_info.h;
qglUseProgramObjectARB(shader->program);
qglUniform1iARB(shader->sampler, 0);
qglUniform2fvARB(shader->screenSize, 1, screenSize);
Gui_DrawRect(0.0, 0.0, screen_info.w, screen_info.h, color_w, color_w, color_w, color_w, BM_OPAQUE, load_screen_tex);
if(value >= 0)
{
Bar[BAR_LOADING].Show(value);
}
qglDepthMask(GL_TRUE);
qglPopClientAttrib();
qglPopAttrib();
Engine_GLSwapWindow();
}
/*
=============
R_DrawAliasVolumeShadow
based on code from BeefQuake R6
=============
*/
void R_DrawAliasVolumeShadow (maliasmodel_t *paliashdr, vec3_t bbox[8])
{
vec3_t light, temp, vecAdd;
float dist, highest, lowest, projected_distance;
float angle, cosp, sinp, cosy, siny, cosr, sinr, ix, iy, iz;
int i, lnum;
dlight_t *dl;
dl = r_newrefdef.dlights;
VectorSet(vecAdd, 680,0,1024); // set base vector, was 576,0,1024
// compute average light vector from dlights
for (i=0, lnum=0; i<r_newrefdef.num_dlights; i++, dl++)
{
if (VectorCompare(dl->origin, currententity->origin))
continue;
VectorSubtract(dl->origin, currententity->origin, temp);
dist = dl->intensity - VectorLength(temp);
if (dist <= 0)
continue;
lnum++;
// Factor in the intensity of a dlight
VectorScale (temp, dist*0.25, temp);
VectorAdd (vecAdd, temp, vecAdd);
}
VectorNormalize(vecAdd);
VectorScale(vecAdd, 1024, vecAdd);
// get projection distance from lightspot height
highest = lowest = bbox[0][2];
for (i=0; i<8; i++) {
if (bbox[i][2] > highest) highest = bbox[i][2];
if (bbox[i][2] < lowest) lowest = bbox[i][2];
}
projected_distance = (fabs(highest - lightspot[2]) + (highest-lowest)) / vecAdd[2];
VectorCopy(vecAdd, light);
/*cosy = cos(-currententity->angles[YAW] / 180 * M_PI);
siny = sin(-currententity->angles[YAW] / 180 * M_PI);
ix = light[0], iy = light[1];
light[0] = (cosy * (ix - 0) + siny * (0 - iy) + 0);
light[1] = (cosy * (iy - 0) + siny * (ix - 0) + 0);
light[2] += 8;*/
// reverse-rotate light vector based on angles
angle = -currententity->angles[PITCH] / 180 * M_PI;
cosp = cos(angle), sinp = sin(angle);
angle = -currententity->angles[YAW] / 180 * M_PI;
cosy = cos(angle), siny = sin(angle);
angle = currententity->angles[ROLL] / 180 * M_PI; // roll is backwards
cosr = cos(angle), sinr = sin(angle);
// rotate for yaw (z axis)
ix = light[0], iy = light[1];
light[0] = cosy * ix - siny * iy + 0;
light[1] = siny * ix + cosy * iy + 0;
// rotate for pitch (y axis)
ix = light[0], iz = light[2];
light[0] = cosp * ix + 0 + sinp * iz;
light[2] = -sinp * ix + 0 + cosp * iz;
// rotate for roll (x axis)
iy = light[1], iz = light[2];
light[1] = 0 + cosr * iy - sinr * iz;
light[2] = 0 + sinr * iy + cosr * iz;
// set up stenciling
if (!r_shadowvolumes->value)
{
qglPushAttrib(GL_STENCIL_BUFFER_BIT); // save stencil buffer
qglClear(GL_STENCIL_BUFFER_BIT);
qglColorMask(0,0,0,0);
GL_DepthMask(0);
GL_DepthFunc(GL_LESS);
GL_Enable(GL_STENCIL_TEST);
qglStencilFunc(GL_ALWAYS, 0, 255);
// qglStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
// qglStencilMask (255);
}
// build shadow volumes and render each to stencil buffer
for (i=0; i<paliashdr->num_meshes; i++)
{
if (paliashdr->meshes[i].skins[currententity->skinnum].renderparms.nodraw
|| paliashdr->meshes[i].skins[currententity->skinnum].renderparms.alphatest
|| paliashdr->meshes[i].skins[currententity->skinnum].renderparms.noshadow)
continue;
R_BuildShadowVolume (paliashdr, i, light, projected_distance, r_shadowvolumes->value);
GL_LockArrays (shadow_va);
if (!r_shadowvolumes->value)
{
if (gl_config.atiSeparateStencil && gl_config.extStencilWrap) // Barnes ATI stenciling
{
GL_Disable(GL_CULL_FACE);
qglStencilOpSeparateATI (GL_BACK, GL_KEEP, GL_INCR_WRAP_EXT, GL_KEEP);
qglStencilOpSeparateATI (GL_FRONT, GL_KEEP, GL_DECR_WRAP_EXT, GL_KEEP);
R_DrawShadowVolume ();
GL_Enable(GL_CULL_FACE);
}
else if (gl_config.extStencilTwoSide && gl_config.extStencilWrap) // Echon's two-sided stenciling
{
GL_Disable(GL_CULL_FACE);
qglEnable (GL_STENCIL_TEST_TWO_SIDE_EXT);
qglActiveStencilFaceEXT (GL_BACK);
qglStencilOp (GL_KEEP, GL_INCR_WRAP_EXT, GL_KEEP);
qglActiveStencilFaceEXT (GL_FRONT);
qglStencilOp (GL_KEEP, GL_DECR_WRAP_EXT, GL_KEEP);
R_DrawShadowVolume ();
qglDisable (GL_STENCIL_TEST_TWO_SIDE_EXT);
GL_Enable(GL_CULL_FACE);
}
else
{ // increment stencil if backface is behind depthbuffer
GL_CullFace(GL_BACK); // quake is backwards, this culls front faces
qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
R_DrawShadowVolume ();
// decrement stencil if frontface is behind depthbuffer
GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
R_DrawShadowVolume ();
}
}
else
R_DrawShadowVolume ();
GL_UnlockArrays ();
}
// end stenciling and draw stenciled volume
if (!r_shadowvolumes->value)
{
GL_CullFace(GL_FRONT);
GL_Disable(GL_STENCIL_TEST);
GL_DepthFunc(GL_LEQUAL);
GL_DepthMask(1);
qglColorMask(1,1,1,1);
// draw shadows for this model now
R_ShadowBlend (aliasShadowAlpha * currententity->alpha); // was r_shadowalpha->value
qglPopAttrib(); // restore stencil buffer
}
}