forked from FWGS/Paranoia2
576 lines
15 KiB
C++
576 lines
15 KiB
C++
//
|
|
// written by BUzer for HL: Paranoia modification
|
|
//
|
|
// 2006
|
|
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "const.h"
|
|
#include "com_model.h"
|
|
#include "r_studioint.h"
|
|
#include "ref_params.h"
|
|
#include "r_efx.h"
|
|
#include "event_api.h"
|
|
#include "pm_defs.h"
|
|
#include "pmtrace.h"
|
|
#include "triangleapi.h"
|
|
#include "gl_local.h"
|
|
#include "stringlib.h"
|
|
#include "gl_world.h"
|
|
#include "gl_shader.h"
|
|
#include "vertex_fmt.h"
|
|
|
|
void GL_GpuMemUsage_f( void )
|
|
{
|
|
GLint cur_avail_mem_kb = 0;
|
|
GLint total_mem_kb = 0;
|
|
|
|
if( glConfig.hardware_type == GLHW_NVIDIA )
|
|
{
|
|
pglGetIntegerv( GL_GPU_MEM_INFO_TOTAL_AVAILABLE_MEM_NVX, &total_mem_kb );
|
|
pglGetIntegerv( GL_GPU_MEM_INFO_CURRENT_AVAILABLE_MEM_NVX, &cur_avail_mem_kb );
|
|
}
|
|
|
|
Msg( "TEX used memory %s\n", Q_memprint( RENDER_GET_PARM( PARM_TEX_MEMORY, 0 )));
|
|
Msg( "VBO used memory %s\n", Q_memprint( tr.total_vbo_memory ));
|
|
Msg( "GPU used memory %s\n", Q_memprint(( total_mem_kb - cur_avail_mem_kb ) * 1024 ));
|
|
}
|
|
|
|
void DBG_PrintVertexVBOSizes( void )
|
|
{
|
|
if( developer_level < at_aiconsole )
|
|
return;
|
|
|
|
ALERT( at_console, "sizeof( bvert_v0_gl21_t ) == %d bytes\n", sizeof( bvert_v0_gl21_t ));
|
|
ALERT( at_console, "sizeof( bvert_v0_gl30_t ) == %d bytes\n", sizeof( bvert_v0_gl30_t ));
|
|
ALERT( at_console, "sizeof( gvert_v0_gl21_t ) == %d bytes\n", sizeof( gvert_v0_gl21_t ));
|
|
ALERT( at_console, "sizeof( gvert_v0_gl30_t ) == %d bytes\n", sizeof( gvert_v0_gl30_t ));
|
|
ALERT( at_console, "sizeof( gvert_v1_gl21_t ) == %d bytes\n", sizeof( gvert_v1_gl21_t ));
|
|
ALERT( at_console, "sizeof( gvert_v1_gl30_t ) == %d bytes\n", sizeof( gvert_v1_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v0_gl21_t ) == %d bytes\n", sizeof( svert_v0_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v0_gl30_t ) == %d bytes\n", sizeof( svert_v0_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v1_gl21_t ) == %d bytes\n", sizeof( svert_v1_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v1_gl30_t ) == %d bytes\n", sizeof( svert_v1_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v2_gl21_t ) == %d bytes\n", sizeof( svert_v2_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v2_gl30_t ) == %d bytes\n", sizeof( svert_v2_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v3_gl21_t ) == %d bytes\n", sizeof( svert_v3_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v3_gl30_t ) == %d bytes\n", sizeof( svert_v3_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v4_gl21_t ) == %d bytes\n", sizeof( svert_v4_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v4_gl30_t ) == %d bytes\n", sizeof( svert_v4_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v5_gl21_t ) == %d bytes\n", sizeof( svert_v5_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v5_gl30_t ) == %d bytes\n", sizeof( svert_v5_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v6_gl21_t ) == %d bytes\n", sizeof( svert_v6_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v6_gl30_t ) == %d bytes\n", sizeof( svert_v6_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v7_gl21_t ) == %d bytes\n", sizeof( svert_v7_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v7_gl30_t ) == %d bytes\n", sizeof( svert_v7_gl30_t ));
|
|
ALERT( at_console, "sizeof( svert_v8_gl21_t ) == %d bytes\n", sizeof( svert_v8_gl21_t ));
|
|
ALERT( at_console, "sizeof( svert_v8_gl30_t ) == %d bytes\n", sizeof( svert_v8_gl30_t ));
|
|
}
|
|
|
|
// some simple helpers to draw a cube in the special way the ambient visualization wants
|
|
static float *CubeSide( const vec3_t pos, float size, int vert )
|
|
{
|
|
static vec3_t side;
|
|
|
|
VectorCopy( pos, side );
|
|
side[0] += (vert & 1) ? -size : size;
|
|
side[1] += (vert & 2) ? -size : size;
|
|
side[2] += (vert & 4) ? -size : size;
|
|
|
|
return side;
|
|
}
|
|
|
|
static void CubeFace( const vec3_t org, int v0, int v1, int v2, int v3, float size, const byte *color )
|
|
{
|
|
uint scale = tr.lightstyle[0];
|
|
uint unclamped[3];
|
|
int col[3];
|
|
|
|
unclamped[0] = TEXTURE_TO_TEXGAMMA( color[0] ) * scale;
|
|
unclamped[1] = TEXTURE_TO_TEXGAMMA( color[1] ) * scale;
|
|
unclamped[2] = TEXTURE_TO_TEXGAMMA( color[2] ) * scale;
|
|
|
|
col[0] = min((unclamped[0] >> 7), 255 );
|
|
col[1] = min((unclamped[1] >> 7), 255 );
|
|
col[2] = min((unclamped[2] >> 7), 255 );
|
|
|
|
// pglColor3ub( col[0], col[1], col[2] );
|
|
pglColor3ub( color[0], color[1], color[2] );
|
|
pglVertex3fv( CubeSide( org, size, v0 ));
|
|
pglVertex3fv( CubeSide( org, size, v1 ));
|
|
pglVertex3fv( CubeSide( org, size, v2 ));
|
|
pglVertex3fv( CubeSide( org, size, v3 ));
|
|
}
|
|
|
|
void R_RenderLightProbe( mlightprobe_t *probe )
|
|
{
|
|
float rad = 4.0f;
|
|
|
|
pglBegin( GL_QUADS );
|
|
|
|
CubeFace( probe->origin, 4, 6, 2, 0, rad, probe->cube.color[0] );
|
|
CubeFace( probe->origin, 7, 5, 1, 3, rad, probe->cube.color[1] );
|
|
CubeFace( probe->origin, 0, 1, 5, 4, rad, probe->cube.color[2] );
|
|
CubeFace( probe->origin, 3, 2, 6, 7, rad, probe->cube.color[3] );
|
|
CubeFace( probe->origin, 2, 3, 1, 0, rad, probe->cube.color[4] );
|
|
CubeFace( probe->origin, 4, 5, 7, 6, rad, probe->cube.color[5] );
|
|
|
|
pglEnd ();
|
|
}
|
|
|
|
void R_RenderCubemap( mcubemap_t *cube )
|
|
{
|
|
float rad = (float)cube->size * 0.1f;
|
|
byte color[3] = { 127, 127, 127 };
|
|
|
|
pglBegin( GL_QUADS );
|
|
|
|
CubeFace( cube->origin, 4, 6, 2, 0, rad, color );
|
|
CubeFace( cube->origin, 7, 5, 1, 3, rad, color );
|
|
CubeFace( cube->origin, 0, 1, 5, 4, rad, color );
|
|
CubeFace( cube->origin, 3, 2, 6, 7, rad, color );
|
|
CubeFace( cube->origin, 2, 3, 1, 0, rad, color );
|
|
CubeFace( cube->origin, 4, 5, 7, 6, rad, color );
|
|
|
|
pglEnd ();
|
|
}
|
|
|
|
void R_RenderLightProbeInternal( const Vector &origin, const Vector lightCube[] )
|
|
{
|
|
mlightprobe_t probe;
|
|
|
|
for( int i = 0; i < 6; i++ )
|
|
{
|
|
probe.cube.color[i][0] = lightCube[i].x * 255;
|
|
probe.cube.color[i][1] = lightCube[i].y * 255;
|
|
probe.cube.color[i][2] = lightCube[i].z * 255;
|
|
}
|
|
probe.origin = origin;
|
|
|
|
R_RenderLightProbe( &probe );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_DrawAABB
|
|
|
|
===============
|
|
*/
|
|
static void R_DrawAABB( const Vector &absmin, const Vector &absmax, int contents )
|
|
{
|
|
vec3_t bbox[8];
|
|
int i;
|
|
|
|
// compute a full bounding box
|
|
for( i = 0; i < 8; i++ )
|
|
{
|
|
bbox[i][0] = ( i & 1 ) ? absmin[0] : absmax[0];
|
|
bbox[i][1] = ( i & 2 ) ? absmin[1] : absmax[1];
|
|
bbox[i][2] = ( i & 4 ) ? absmin[2] : absmax[2];
|
|
}
|
|
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglDisable( GL_DEPTH_TEST );
|
|
|
|
switch( contents )
|
|
{
|
|
case CONTENTS_EMPTY:
|
|
pglColor4f( 0.5f, 1.0f, 0.0f, 1.0f ); // green for empty
|
|
break;
|
|
case CONTENTS_SOLID:
|
|
pglColor4f( 1.0f, 0.0f, 0.0f, 1.0f ); // red for solid
|
|
break;
|
|
case CONTENTS_WATER:
|
|
pglColor4f( 0.0f, 0.5f, 1.0f, 1.0f ); // blue for water
|
|
break;
|
|
default:
|
|
pglColor4f( 0.5f, 0.5f, 0.5f, 1.0f ); // gray as default
|
|
break;
|
|
}
|
|
pglBegin( GL_LINES );
|
|
|
|
for( i = 0; i < 2; i += 1 )
|
|
{
|
|
pglVertex3fv( bbox[i+0] );
|
|
pglVertex3fv( bbox[i+2] );
|
|
pglVertex3fv( bbox[i+4] );
|
|
pglVertex3fv( bbox[i+6] );
|
|
pglVertex3fv( bbox[i+0] );
|
|
pglVertex3fv( bbox[i+4] );
|
|
pglVertex3fv( bbox[i+2] );
|
|
pglVertex3fv( bbox[i+6] );
|
|
pglVertex3fv( bbox[i*2+0] );
|
|
pglVertex3fv( bbox[i*2+1] );
|
|
pglVertex3fv( bbox[i*2+4] );
|
|
pglVertex3fv( bbox[i*2+5] );
|
|
}
|
|
|
|
pglEnd();
|
|
pglEnable( GL_DEPTH_TEST );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_RenderVisibleLeafs
|
|
|
|
===============
|
|
*/
|
|
static void R_RenderVisibleLeafs( void )
|
|
{
|
|
mleaf_t *leaf;
|
|
int i;
|
|
|
|
// always skip the leaf 0, because is outside leaf
|
|
for( i = 1, leaf = &worldmodel->leafs[1]; i < worldmodel->numleafs + 1; i++, leaf++ )
|
|
{
|
|
mextraleaf_t *eleaf = LEAF_INFO( leaf, worldmodel );
|
|
|
|
if( CHECKVISBIT( RI->view.pvsarray, leaf->cluster ) && ( leaf->efrags || leaf->nummarksurfaces ))
|
|
{
|
|
R_DrawAABB( eleaf->mins, eleaf->maxs, CONTENTS_WATER );
|
|
R_DrawAABB( Vector( leaf->minmaxs ), Vector( leaf->minmaxs + 3 ), leaf->contents );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DrawViewLeaf
|
|
=============
|
|
*/
|
|
void DrawViewLeaf( void )
|
|
{
|
|
if( !CVAR_TO_BOOL( r_show_viewleaf ))
|
|
return;
|
|
|
|
GL_Blend( GL_FALSE );
|
|
R_RenderVisibleLeafs();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DrawLightProbes
|
|
=============
|
|
*/
|
|
void DrawLightProbes( void )
|
|
{
|
|
int i, j;
|
|
mlightprobe_t *probe;
|
|
mleaf_t *leaf;
|
|
mextraleaf_t *info;
|
|
|
|
if( !CVAR_TO_BOOL( r_show_lightprobes ))
|
|
return;
|
|
|
|
GL_Blend( GL_FALSE );
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
|
|
// draw the all visible probes
|
|
for( i = 1; i < world->numleafs; i++ )
|
|
{
|
|
leaf = (mleaf_t *)&worldmodel->leafs[i];
|
|
info = LEAF_INFO( leaf, worldmodel );
|
|
|
|
if( !CHECKVISBIT( RI->view.pvsarray, leaf->cluster ))
|
|
continue; // not visible from player
|
|
|
|
for( j = 0; j < info->num_lightprobes; j++ )
|
|
{
|
|
probe = info->ambient_light + j;
|
|
R_RenderLightProbe( probe );
|
|
}
|
|
}
|
|
|
|
pglColor3f( 1.0f, 1.0f, 1.0f );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
DrawCubeMaps
|
|
=============
|
|
*/
|
|
void DrawCubeMaps( void )
|
|
{
|
|
mcubemap_t *cm;
|
|
|
|
if( !CVAR_TO_BOOL( r_show_cubemaps ))
|
|
return;
|
|
|
|
GL_Blend( GL_FALSE );
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
|
|
// draw the all cubemaps
|
|
for( int i = 0; i < world->num_cubemaps; i++ )
|
|
{
|
|
cm = &world->cubemaps[i];
|
|
R_RenderCubemap( cm );
|
|
}
|
|
|
|
pglColor3f( 1.0f, 1.0f, 1.0f );
|
|
}
|
|
|
|
void DBG_DrawBBox( const Vector &mins, const Vector &maxs )
|
|
{
|
|
Vector bbox[8];
|
|
int i;
|
|
|
|
for( i = 0; i < 8; i++ )
|
|
{
|
|
bbox[i][0] = ( i & 1 ) ? mins[0] : maxs[0];
|
|
bbox[i][1] = ( i & 2 ) ? mins[1] : maxs[1];
|
|
bbox[i][2] = ( i & 4 ) ? mins[2] : maxs[2];
|
|
}
|
|
|
|
pglColor4f( 1.0f, 0.0f, 1.0f, 1.0f ); // yellow bboxes for frustum
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglBegin( GL_LINES );
|
|
|
|
for( i = 0; i < 2; i += 1 )
|
|
{
|
|
pglVertex3fv( bbox[i+0] );
|
|
pglVertex3fv( bbox[i+2] );
|
|
pglVertex3fv( bbox[i+4] );
|
|
pglVertex3fv( bbox[i+6] );
|
|
pglVertex3fv( bbox[i+0] );
|
|
pglVertex3fv( bbox[i+4] );
|
|
pglVertex3fv( bbox[i+2] );
|
|
pglVertex3fv( bbox[i+6] );
|
|
pglVertex3fv( bbox[i*2+0] );
|
|
pglVertex3fv( bbox[i*2+1] );
|
|
pglVertex3fv( bbox[i*2+4] );
|
|
pglVertex3fv( bbox[i*2+5] );
|
|
}
|
|
pglEnd();
|
|
}
|
|
|
|
void DBG_DrawLightFrustum( void )
|
|
{
|
|
if( CVAR_TO_BOOL( r_scissor_light_debug ) && RP_NORMALPASS( ))
|
|
{
|
|
pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
|
|
for( int i = 0; i < MAX_DLIGHTS; i++ )
|
|
{
|
|
CDynLight *pl = &tr.dlights[i];
|
|
|
|
if( !pl->Active( )) continue;
|
|
|
|
if( r_scissor_light_debug->value == 1.0f )
|
|
{
|
|
R_DrawScissorRectangle( pl->x, pl->y, pl->w, pl->h );
|
|
}
|
|
else if( r_scissor_light_debug->value == 2.0f )
|
|
{
|
|
if( pl->type == LIGHT_DIRECTIONAL )
|
|
{
|
|
for( int j = 0; j < NUM_SHADOW_SPLITS + 1; j++ )
|
|
pl->splitFrustum[j].DrawFrustumDebug();
|
|
}
|
|
else pl->frustum.DrawFrustumDebug();
|
|
}
|
|
else
|
|
{
|
|
DBG_DrawBBox( pl->absmin, pl->absmax );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DBG_DrawGlassScissors( void )
|
|
{
|
|
if( CVAR_TO_BOOL( r_scissor_glass_debug ) && RP_NORMALPASS( ))
|
|
{
|
|
// debug scissor code
|
|
GL_BindShader( NULL );
|
|
|
|
// debug scissor code
|
|
for( int k = 0; k < RI->frame.trans_list.Count(); k++ )
|
|
{
|
|
CTransEntry *entry = &RI->frame.trans_list[k];
|
|
entry->RenderScissorDebug();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
DrawTangentSpaces
|
|
|
|
Draws vertex tangent spaces for debugging
|
|
================
|
|
*/
|
|
void DrawTangentSpaces( void )
|
|
{
|
|
float temp[3];
|
|
float vecLen = 4.0f;
|
|
|
|
if( !CVAR_TO_BOOL( cv_show_tbn ))
|
|
return;
|
|
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglDisable( GL_DEPTH_TEST );
|
|
GL_Blend( GL_FALSE );
|
|
pglBegin( GL_LINES );
|
|
|
|
for( int i = 0; i < worldmodel->nummodelsurfaces; i++ )
|
|
{
|
|
msurface_t *surf = &worldmodel->surfaces[i];
|
|
mextrasurf_t *esrf = surf->info;
|
|
|
|
if( FBitSet( surf->flags, SURF_DRAWTURB|SURF_DRAWSKY ))
|
|
continue;
|
|
|
|
bvert_t *mv = &world->vertexes[esrf->firstvertex];
|
|
|
|
for( int j = 0; j < esrf->numverts; j++, mv++ )
|
|
{
|
|
pglColor3f( 1.0f, 0.0f, 0.0f );
|
|
pglVertex3fv( mv->vertex );
|
|
VectorMA( mv->vertex, vecLen, Vector( mv->tangent ), temp );
|
|
pglVertex3fv( temp );
|
|
|
|
pglColor3f( 0.0f, 1.0f, 0.0f );
|
|
pglVertex3fv( mv->vertex );
|
|
VectorMA( mv->vertex, vecLen, Vector( mv->binormal ), temp );
|
|
pglVertex3fv( temp );
|
|
|
|
pglColor3f( 0.0f, 0.0f, 1.0f );
|
|
pglVertex3fv( mv->vertex );
|
|
VectorMA( mv->vertex, vecLen, Vector( mv->normal ), temp );
|
|
pglVertex3fv( temp );
|
|
}
|
|
}
|
|
|
|
pglEnd();
|
|
pglEnable( GL_DEPTH_TEST );
|
|
}
|
|
|
|
void DrawWireFrame( void )
|
|
{
|
|
int i;
|
|
|
|
if( !CVAR_TO_BOOL( r_wireframe ))
|
|
return;
|
|
|
|
pglEnable( GL_BLEND );
|
|
pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
pglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
|
|
pglColor4f( 1.0f, 1.0f, 1.0f, 0.99f );
|
|
|
|
pglDisable( GL_DEPTH_TEST );
|
|
pglEnable( GL_LINE_SMOOTH );
|
|
GL_BindTexture( GL_TEXTURE0, tr.whiteTexture );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglEnable( GL_POLYGON_SMOOTH );
|
|
pglHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
|
|
pglHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
|
|
|
|
for( i = 0; i < RI->frame.solid_faces.Count(); i++ )
|
|
{
|
|
if( RI->frame.solid_faces[i].m_bDrawType != DRAWTYPE_SURFACE )
|
|
continue;
|
|
|
|
msurface_t *surf = RI->frame.solid_faces[i].m_pSurf;
|
|
mextrasurf_t *es = surf->info;
|
|
|
|
pglBegin( GL_POLYGON );
|
|
for( int j = 0; j < es->numverts; j++ )
|
|
{
|
|
bvert_t *v = &world->vertexes[es->firstvertex + j];
|
|
pglVertex3fv( v->vertex + Vector( v->normal ) * 0.1f );
|
|
}
|
|
pglEnd();
|
|
}
|
|
|
|
pglColor4f( 0.0f, 1.0f, 0.0f, 0.99f );
|
|
for( i = 0; i < RI->frame.trans_list.Count(); i++ )
|
|
{
|
|
if( RI->frame.trans_list[i].m_bDrawType != DRAWTYPE_SURFACE )
|
|
continue;
|
|
|
|
msurface_t *surf = RI->frame.trans_list[i].m_pSurf;
|
|
mextrasurf_t *es = surf->info;
|
|
|
|
pglBegin( GL_POLYGON );
|
|
for( int j = 0; j < es->numverts; j++ )
|
|
{
|
|
bvert_t *v = &world->vertexes[es->firstvertex + j];
|
|
pglVertex3fv( v->vertex + Vector( v->normal ) * 0.1f );
|
|
}
|
|
pglEnd();
|
|
}
|
|
|
|
pglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
|
|
pglDisable( GL_POLYGON_SMOOTH );
|
|
pglDisable( GL_LINE_SMOOTH );
|
|
pglEnable( GL_DEPTH_TEST );
|
|
pglDisable( GL_BLEND );
|
|
}
|
|
|
|
void DrawWirePoly( msurface_t *surf )
|
|
{
|
|
if( !surf ) return;
|
|
|
|
pglEnable( GL_BLEND );
|
|
pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
pglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
|
|
pglColor4f( 0.5f, 1.0f, 0.36f, 0.99f );
|
|
pglLineWidth( 4.0f );
|
|
|
|
pglDisable( GL_DEPTH_TEST );
|
|
pglEnable( GL_LINE_SMOOTH );
|
|
pglEnable( GL_POLYGON_SMOOTH );
|
|
pglHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
|
|
pglHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
|
|
|
|
mextrasurf_t *es = surf->info;
|
|
|
|
pglBegin( GL_POLYGON );
|
|
for( int j = 0; j < es->numverts; j++ )
|
|
{
|
|
bvert_t *v = &world->vertexes[es->firstvertex + j];
|
|
pglVertex3fv( v->vertex + Vector( v->normal ) * 0.1f );
|
|
}
|
|
pglEnd();
|
|
|
|
pglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
|
|
pglDisable( GL_POLYGON_SMOOTH );
|
|
pglDisable( GL_LINE_SMOOTH );
|
|
pglEnable( GL_DEPTH_TEST );
|
|
pglDisable( GL_BLEND );
|
|
pglLineWidth( 1.0f );
|
|
}
|
|
|
|
void R_ShowLightMaps( void )
|
|
{
|
|
int index = 0;
|
|
|
|
if( !CVAR_TO_BOOL( r_showlightmaps ))
|
|
return;
|
|
|
|
index = r_showlightmaps->value - 1.0f;
|
|
if( tr.lightmaps[index].state == LM_FREE )
|
|
return;
|
|
|
|
GL_BindTexture( GL_TEXTURE0, tr.lightmaps[index].lightmap );
|
|
pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
|
|
GL_Setup2D();
|
|
|
|
pglBegin( GL_QUADS );
|
|
pglTexCoord2f( 0.0f, 0.0f );
|
|
pglVertex2f( 0.0f, 0.0f );
|
|
pglTexCoord2f( 1.0f, 0.0f );
|
|
pglVertex2f( glState.width, 0.0f );
|
|
pglTexCoord2f( 1.0f, 1.0f );
|
|
pglVertex2f( glState.width, glState.height );
|
|
pglTexCoord2f( 0.0f, 1.0f );
|
|
pglVertex2f( 0.0f, glState.height );
|
|
pglEnd();
|
|
|
|
GL_Setup3D();
|
|
} |