/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglDisable( GL_CLIP_PLANE0 );
qglDisable( GL_CULL_FACE );
GL_Bind( tr.whiteImage );
qglLoadIdentity();
qglColor3f( 0.6f, 0.6f, 0.6f );
GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// qglColor3f( 1, 0, 0 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglBegin( GL_QUADS );
qglVertex3f( -100, 100, -10 );
qglVertex3f( 100, 100, -10 );
qglVertex3f( 100, -100, -10 );
qglVertex3f( -100, -100, -10 );
qglEnd();
qglColor4f( 1,1,1,1 );
qglDisable( GL_STENCIL_TEST );
}
/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
#if defined(VV_LIGHTING) && defined(_XBOX)
StencilShadower.FinishShadows();
#else
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
#ifdef _DEBUG_STENCIL_SHADOWS
return;
#endif
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
bool planeZeroBack = false;
if (qglIsEnabled(GL_CLIP_PLANE0))
{
planeZeroBack = true;
qglDisable (GL_CLIP_PLANE0);
}
GL_Cull(CT_TWO_SIDED);
//qglDisable (GL_CULL_FACE);
GL_Bind( tr.whiteImage );
qglPushMatrix();
qglLoadIdentity ();
// qglColor3f( 0.6f, 0.6f, 0.6f );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// qglColor3f( 1, 0, 0 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglColor4f( 0.0f, 0.0f, 0.0f, 0.5f );
//GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
qglBegin( GL_QUADS );
qglVertex3f( -100, 100, -10 );
qglVertex3f( 100, 100, -10 );
qglVertex3f( 100, -100, -10 );
qglVertex3f( -100, -100, -10 );
qglEnd ();
qglColor4f(1,1,1,1);
qglDisable( GL_STENCIL_TEST );
if (planeZeroBack)
{
qglEnable (GL_CLIP_PLANE0);
}
qglPopMatrix();
#endif // VV_LIGHTING && _XBOX
}
/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglDisable (GL_CLIP_PLANE0);
qglDisable (GL_CULL_FACE);
GL_Bind( tr.whiteImage );
qglLoadIdentity ();
qglColor3f( 0.6f, 0.6f, 0.6f );
GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// qglColor3f( 1, 0, 0 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
#ifdef HAVE_GLES
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglDisableClientState( GL_COLOR_ARRAY );
GLfloat vtx[] = {
-100, 100, -10,
100, 100, -10,
100, -100, -10,
-100, -100, -10
};
qglVertexPointer ( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglEnableClientState( GL_COLOR_ARRAY );
#else
qglBegin( GL_QUADS );
qglVertex3f( -100, 100, -10 );
qglVertex3f( 100, 100, -10 );
qglVertex3f( 100, -100, -10 );
qglVertex3f( -100, -100, -10 );
qglEnd ();
#endif
qglColor4f(1,1,1,1);
qglDisable( GL_STENCIL_TEST );
}
/*
=================
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();
}
/*
==============
CZWnd::Z_DrawCameraIcon
==============
*/
void CZWnd::Z_DrawCameraIcon( void ) {
float x, y;
int xCam = z.width / 4 / z.scale; // sikk -
x = 0;
y = g_pParentWnd->GetCamera()->Camera().origin[2];
qglColor3f( 0.0, 0.0, 1.0 );
qglBegin( GL_LINE_STRIP );
qglVertex3f( x - xCam, y, 0 );
qglVertex3f( x, y + CAM_GIZMO, 0 );
qglVertex3f( x + xCam, y, 0 );
qglVertex3f( x, y - CAM_GIZMO, 0 );
qglVertex3f( x - xCam, y, 0 );
qglVertex3f( x + xCam, y, 0 );
qglVertex3f( x + xCam, y - CAM_HEIGHT, 0 );
qglVertex3f( x - xCam, y - CAM_HEIGHT, 0 );
qglVertex3f( x - xCam, y, 0 );
qglEnd();
}
void ZDrawCameraIcon (void)
{
float x, y;
float xCam = z.width/4/z.scale, gizmo = 8 / z.scale, height = 48 / z.scale;
x = 0;
y = g_pParentWnd->GetCamWnd()->Camera()->origin[2];
qglColor3f (0.0, 0.0, 1.0);
qglBegin(GL_LINE_STRIP);
qglVertex3f (x-xCam,y,0);
qglVertex3f (x,y+gizmo,0);
qglVertex3f (x+xCam,y,0);
qglVertex3f (x,y-gizmo,0);
qglVertex3f (x-xCam,y,0);
qglVertex3f (x+xCam,y,0);
qglVertex3f (x+xCam,y-height,0);
qglVertex3f (x-xCam,y-height,0);
qglVertex3f (x-xCam,y,0);
qglEnd ();
}
// Draws from modelview space
void GLRB_SurfaceAxis( void ) {
GL_Bind( tr.whiteImage );
qglLineWidth( 3 );
qglBegin( GL_LINES );
qglColor3f( 1,0,0 );
qglVertex3f( 0,0,0 );
qglVertex3f( 16,0,0 );
qglColor3f( 0,1,0 );
qglVertex3f( 0,0,0 );
qglVertex3f( 0,16,0 );
qglColor3f( 0,0,1 );
qglVertex3f( 0,0,0 );
qglVertex3f( 0,0,16 );
qglEnd();
qglLineWidth( 1 );
}
/*
===================
RB_SurfaceAxis
Draws x/y/z lines from the origin for orientation debugging
===================
*/
static void RB_SurfaceAxis( void ) {
// FIXME: implement this
#if 0
GL_BindToTMU( tr.whiteImage, TB_COLORMAP );
GL_State( GLS_DEFAULT );
qglLineWidth( 3 );
qglBegin( GL_LINES );
qglColor3f( 1,0,0 );
qglVertex3f( 0,0,0 );
qglVertex3f( 16,0,0 );
qglColor3f( 0,1,0 );
qglVertex3f( 0,0,0 );
qglVertex3f( 0,16,0 );
qglColor3f( 0,0,1 );
qglVertex3f( 0,0,0 );
qglVertex3f( 0,0,16 );
qglEnd();
qglLineWidth( 1 );
#endif
}
/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
#ifdef _DEBUG_STENCIL_SHADOWS
return;
#endif
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
bool planeZeroBack = false;
if (qglIsEnabled(GL_CLIP_PLANE0))
{
planeZeroBack = true;
qglDisable (GL_CLIP_PLANE0);
}
GL_Cull(CT_TWO_SIDED);
//qglDisable (GL_CULL_FACE);
GL_Bind( tr.whiteImage );
qglPushMatrix();
qglLoadIdentity ();
// qglColor3f( 0.6f, 0.6f, 0.6f );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// qglColor3f( 1, 0, 0 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglColor4f( 0.0f, 0.0f, 0.0f, 0.5f );
//GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
#ifdef HAVE_GLES
GLfloat vtx[] = {
-100, 100, -10,
100, 100, -10,
100, -100, -10,
-100, -100, -10
};
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglDisableClientState( GL_COLOR_ARRAY );
qglVertexPointer ( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglEnableClientState( GL_COLOR_ARRAY );
#else
qglBegin( GL_QUADS );
qglVertex3f( -100, 100, -10 );
qglVertex3f( 100, 100, -10 );
qglVertex3f( 100, -100, -10 );
qglVertex3f( -100, -100, -10 );
qglEnd ();
#endif
qglColor4f(1,1,1,1);
qglDisable( GL_STENCIL_TEST );
if (planeZeroBack)
{
qglEnable (GL_CLIP_PLANE0);
}
qglPopMatrix();
}
/*
================
glBox
================
*/
void glBox(idVec4 &color, idVec3 &point, float size) {
idVec3 mins(point);
idVec3 maxs(point);
mins[0] -= size;
mins[1] += size;
mins[2] -= size;
maxs[0] += size;
maxs[1] -= size;
maxs[2] += size;
idVec4 saveColor;
qglGetFloatv(GL_CURRENT_COLOR, saveColor.ToFloatPtr());
qglColor3fv( color.ToFloatPtr() );
qglBegin(GL_LINE_LOOP);
qglVertex3f(mins[0],mins[1],mins[2]);
qglVertex3f(maxs[0],mins[1],mins[2]);
qglVertex3f(maxs[0],maxs[1],mins[2]);
qglVertex3f(mins[0],maxs[1],mins[2]);
qglEnd();
qglBegin(GL_LINE_LOOP);
qglVertex3f(mins[0],mins[1],maxs[2]);
qglVertex3f(maxs[0],mins[1],maxs[2]);
qglVertex3f(maxs[0],maxs[1],maxs[2]);
qglVertex3f(mins[0],maxs[1],maxs[2]);
qglEnd();
qglBegin(GL_LINES);
qglVertex3f(mins[0],mins[1],mins[2]);
qglVertex3f(mins[0],mins[1],maxs[2]);
qglVertex3f(mins[0],maxs[1],maxs[2]);
qglVertex3f(mins[0],maxs[1],mins[2]);
qglVertex3f(maxs[0],mins[1],mins[2]);
qglVertex3f(maxs[0],mins[1],maxs[2]);
qglVertex3f(maxs[0],maxs[1],maxs[2]);
qglVertex3f(maxs[0],maxs[1],mins[2]);
qglEnd();
qglColor4fv(saveColor.ToFloatPtr());
}
void glBox(idVec3 &color, idVec3 &point, float size)
{
idVec3 mins(point);
idVec3 maxs(point);
mins[0] -= size;
mins[1] += size;
mins[2] -= size;
maxs[0] += size;
maxs[1] -= size;
maxs[2] += size;
qglColor3fv(color);
qglBegin(GL_LINE_LOOP);
qglVertex3f(mins[0], mins[1], mins[2]);
qglVertex3f(maxs[0], mins[1], mins[2]);
qglVertex3f(maxs[0], maxs[1], mins[2]);
qglVertex3f(mins[0], maxs[1], mins[2]);
qglEnd();
qglBegin(GL_LINE_LOOP);
qglVertex3f(mins[0], mins[1], maxs[2]);
qglVertex3f(maxs[0], mins[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], maxs[2]);
qglVertex3f(mins[0], maxs[1], maxs[2]);
qglEnd();
qglBegin(GL_LINES);
qglVertex3f(mins[0], mins[1], mins[2]);
qglVertex3f(mins[0], mins[1], maxs[2]);
qglVertex3f(mins[0], maxs[1], maxs[2]);
qglVertex3f(mins[0], maxs[1], mins[2]);
qglVertex3f(maxs[0], mins[1], mins[2]);
qglVertex3f(maxs[0], mins[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], mins[2]);
qglEnd();
}
void CZClip::Paint(void)
{
float x, y;
int xCam = z.width/4; // hmmm, a rather unpleasant and obscure global name, but it was already called that so...
qglColor3f (ZCLIP_COLOUR);//1.0, 0.0, 1.0);
// draw TOP marker...
//
x = 0;
y = m_iZClipTop;
if (m_bEnabled)
qglBegin(GL_QUADS);
else
qglBegin(GL_LINE_LOOP);
qglVertex3f (x-xCam,y,0);
qglVertex3f (x-xCam,y+ZCLIP_BAR_THICKNESS,0);
qglVertex3f (x+xCam,y+ZCLIP_BAR_THICKNESS,0);
qglVertex3f (x+xCam,y,0);
qglEnd ();
qglColor3f (ZCLIP_COLOUR_DIM);//0.8, 0.0, 0.8);
if (m_bEnabled)
qglBegin(GL_TRIANGLES);
else
qglBegin(GL_LINE_LOOP);
qglVertex3f (x,(y+ZCLIP_BAR_THICKNESS),0);
qglVertex3f (x-xCam,(y+ZCLIP_BAR_THICKNESS)+(ZCLIP_ARROWHEIGHT/2),0);
qglVertex3f (x+xCam,(y+ZCLIP_BAR_THICKNESS)+(ZCLIP_ARROWHEIGHT/2),0);
qglEnd ();
// draw bottom marker...
//
qglColor3f (ZCLIP_COLOUR);//1.0, 0.0, 1.0);
x = 0;
y = m_iZClipBottom;
if (m_bEnabled)
qglBegin(GL_QUADS);
else
qglBegin(GL_LINE_LOOP);
qglVertex3f (x-xCam,y,0);
qglVertex3f (x-xCam,y-ZCLIP_BAR_THICKNESS,0);
qglVertex3f (x+xCam,y-ZCLIP_BAR_THICKNESS,0);
qglVertex3f (x+xCam,y,0);
qglEnd ();
qglColor3f (ZCLIP_COLOUR_DIM);//0.8, 0.0, 0.8);
if (m_bEnabled)
qglBegin(GL_TRIANGLES);
else
qglBegin(GL_LINE_LOOP);
qglVertex3f (x,(y-ZCLIP_BAR_THICKNESS),0);
qglVertex3f (x-xCam,(y-ZCLIP_BAR_THICKNESS)-(ZCLIP_ARROWHEIGHT/2),0);
qglVertex3f (x+xCam,(y-ZCLIP_BAR_THICKNESS)-(ZCLIP_ARROWHEIGHT/2),0);
qglEnd ();
}
/*
================
RB_DrawBounds
================
*/
void RB_DrawBounds( const idBounds &bounds ) {
if ( bounds.IsCleared() ) {
return;
}
qglBegin( GL_LINE_LOOP );
qglVertex3f( bounds[0][0], bounds[0][1], bounds[0][2] );
qglVertex3f( bounds[0][0], bounds[1][1], bounds[0][2] );
qglVertex3f( bounds[1][0], bounds[1][1], bounds[0][2] );
qglVertex3f( bounds[1][0], bounds[0][1], bounds[0][2] );
qglEnd();
qglBegin( GL_LINE_LOOP );
qglVertex3f( bounds[0][0], bounds[0][1], bounds[1][2] );
qglVertex3f( bounds[0][0], bounds[1][1], bounds[1][2] );
qglVertex3f( bounds[1][0], bounds[1][1], bounds[1][2] );
qglVertex3f( bounds[1][0], bounds[0][1], bounds[1][2] );
qglEnd();
qglBegin( GL_LINES );
qglVertex3f( bounds[0][0], bounds[0][1], bounds[0][2] );
qglVertex3f( bounds[0][0], bounds[0][1], bounds[1][2] );
qglVertex3f( bounds[0][0], bounds[1][1], bounds[0][2] );
qglVertex3f( bounds[0][0], bounds[1][1], bounds[1][2] );
qglVertex3f( bounds[1][0], bounds[0][1], bounds[0][2] );
qglVertex3f( bounds[1][0], bounds[0][1], bounds[1][2] );
qglVertex3f( bounds[1][0], bounds[1][1], bounds[0][2] );
qglVertex3f( bounds[1][0], bounds[1][1], bounds[1][2] );
qglEnd();
}
void CCamWnd::Cam_Draw()
{
brush_t *brush;
face_t *face;
float screenaspect;
float yfov;
double start, end;
int i;
/*
FILE *f = fopen("g:/nardo/raduffy/editorhack.dat", "w");
if (f != NULL) {
fwrite(&m_Camera.origin[0], sizeof(float), 1, f);
fwrite(&m_Camera.origin[1], sizeof(float), 1, f);
fwrite(&m_Camera.origin[2], sizeof(float), 1, f);
fwrite(&m_Camera.angles[PITCH], sizeof(float), 1, f);
fwrite(&m_Camera.angles[YAW], sizeof(float), 1, f);
fclose(f);
}
*/
if (!active_brushes.next)
return; // not valid yet
if (m_Camera.timing)
start = Sys_DoubleTime ();
//
// clear
//
QE_CheckOpenGLForErrors();
qglViewport(0, 0, m_Camera.width, m_Camera.height);
qglScissor(0, 0, m_Camera.width, m_Camera.height);
qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0],
g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1],
g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// set up viewpoint
//
vec5_t lightPos;
if (g_PrefsDlg.m_bGLLighting)
{
qglEnable(GL_LIGHTING);
//qglEnable(GL_LIGHT0);
lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
lightPos[3] = 1.0;
qglLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightPos);
//qglLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
//lightPos[0] = lightPos[1] = lightPos[2] = 3.5;
//qglLightfv(GL_LIGHT0, GL_AMBIENT, lightPos);
}
else
{
qglDisable(GL_LIGHTING);
}
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
screenaspect = (float)m_Camera.width / m_Camera.height;
yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI;
qgluPerspective (yfov, screenaspect, 2, 8192);
qglRotatef (-90, 1, 0, 0); // put Z going up
qglRotatef (90, 0, 0, 1); // put Z going up
qglRotatef (m_Camera.angles[0], 0, 1, 0);
qglRotatef (-m_Camera.angles[1], 0, 0, 1);
qglTranslatef (-m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]);
Cam_BuildMatrix ();
//if (m_Camera.draw_mode == cd_light)
//{
// if (g_PrefsDlg.m_bGLLighting)
// {
// VectorCopy(m_Camera.origin, lightPos);
// lightPos[3] = 1;
// qglLightfv(GL_LIGHT0, GL_POSITION, lightPos);
// }
//}
InitCull ();
//
// draw stuff
//
GLfloat lAmbient[] = {1.0, 1.0, 1.0, 1.0};
switch (m_Camera.draw_mode)
{
case cd_wire:
qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_TEXTURE_1D);
qglDisable(GL_BLEND);
qglDisable(GL_DEPTH_TEST);
qglColor3f(1.0, 1.0, 1.0);
// qglEnable (GL_LINE_SMOOTH);
break;
case cd_solid:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_BLEND);
qglEnable(GL_DEPTH_TEST);
qglDepthFunc (GL_LEQUAL);
break;
case cd_texture:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglEnable(GL_TEXTURE_2D);
qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglDisable(GL_BLEND);
qglEnable(GL_DEPTH_TEST);
qglDepthFunc (GL_LEQUAL);
break;
case cd_blend:
qglCullFace(GL_FRONT);
qglEnable(GL_CULL_FACE);
qglShadeModel (GL_FLAT);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglEnable(GL_TEXTURE_2D);
qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglDisable(GL_DEPTH_TEST);
qglEnable (GL_BLEND);
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
}
qglMatrixMode(GL_TEXTURE);
m_nNumTransBrushes = 0;
for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
{
//DrawLightRadius(brush);
if (CullBrush (brush))
continue;
if (FilterBrush (brush))
continue;
if ((brush->brush_faces->texdef.flags & (SURF_TRANS33 | SURF_TRANS66)) || (brush->brush_faces->d_texture->bFromShader && brush->brush_faces->d_texture->fTrans != 1.0))
{
m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
}
else
{
//-- if (brush->patchBrush)
//-- m_TransBrushes [ m_nNumTransBrushes++ ] = brush;
//-- else
Brush_Draw(brush);
}
}
if (g_PrefsDlg.m_bGLLighting)
{
qglDisable (GL_LIGHTING);
}
//
//qglDepthMask ( 0 ); // Don't write to depth buffer
qglEnable ( GL_BLEND );
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for ( i = 0; i < m_nNumTransBrushes; i++ )
Brush_Draw (m_TransBrushes[i]);
//qglDepthMask ( 1 ); // Ok, write now
qglMatrixMode(GL_PROJECTION);
//
// now draw selected brushes
//
if (g_PrefsDlg.m_bGLLighting)
{
qglEnable (GL_LIGHTING);
}
qglTranslatef (g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]);
qglMatrixMode(GL_TEXTURE);
brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes;
// draw normally
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
//DrawLightRadius(brush);
//if (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint)
// continue;
Brush_Draw(brush);
}
// blend on top
qglMatrixMode(GL_PROJECTION);
qglDisable (GL_LIGHTING);
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);
qglDisable (GL_TEXTURE_2D);
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
if ( (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) ||
(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint) )
continue;
for (face=brush->brush_faces ; face ; face=face->next)
Face_Draw( face );
}
int nCount = g_ptrSelectedFaces.GetSize();
if (nCount > 0)
{
for (int i = 0; i < nCount; i++)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i));
Face_Draw(selFace);
}
}
// non-zbuffered outline
qglDisable (GL_BLEND);
qglDisable (GL_DEPTH_TEST);
qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
qglColor3f (1, 1, 1);
for (brush = pList->next ; brush != pList ; brush=brush->next)
{
if (g_qeglobals.dontDrawSelectedOutlines || (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) ||
(brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint))
continue;
for (face=brush->brush_faces ; face ; face=face->next)
Face_Draw( face );
}
// edge / vertex flags
if (g_qeglobals.d_select_mode == sel_vertex)
{
qglPointSize (4);
qglColor3f (0,1,0);
qglBegin (GL_POINTS);
for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
qglVertex3fv (g_qeglobals.d_points[i]);
qglEnd ();
qglPointSize (1);
}
else if (g_qeglobals.d_select_mode == sel_edge)
{
float *v1, *v2;
qglPointSize (4);
qglColor3f (0,0,1);
qglBegin (GL_POINTS);
for (i=0 ; i<g_qeglobals.d_numedges ; i++)
{
v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
}
qglEnd ();
qglPointSize (1);
}
g_splineList->draw(static_cast<qboolean>(g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint));
if (g_qeglobals.selectObject && (g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)) {
g_qeglobals.selectObject->drawSelection();
}
//
// draw pointfile
//
qglEnable(GL_DEPTH_TEST);
DrawPathLines ();
if (g_qeglobals.d_pointfile_display_list)
{
Pointfile_Draw();
// glCallList (g_qeglobals.d_pointfile_display_list);
}
// bind back to the default texture so that we don't have problems
// elsewhere using/modifying texture maps between contexts
qglBindTexture( GL_TEXTURE_2D, 0 );
#if 0
// area selection hack
if (g_qeglobals.d_select_mode == sel_area)
{
qglEnable (GL_BLEND);
qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglColor4f(0.0, 0.0, 1.0, 0.25);
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglRectfv(g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR);
qglDisable (GL_BLEND);
}
#endif
qglFinish();
QE_CheckOpenGLForErrors();
// Sys_EndWait();
if (m_Camera.timing)
{
end = Sys_DoubleTime ();
Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start)));
}
}
/**
* @note Unused.
*/
void RB_DrawBounds(vec3_t mins, vec3_t maxs)
{
vec3_t center;
GL_Bind(tr.whiteImage);
GL_State(GLS_POLYMODE_LINE);
// box corners
qglBegin(GL_LINES);
qglColor3f(1, 1, 1);
qglVertex3f(mins[0], mins[1], mins[2]);
qglVertex3f(maxs[0], mins[1], mins[2]);
qglVertex3f(mins[0], mins[1], mins[2]);
qglVertex3f(mins[0], maxs[1], mins[2]);
qglVertex3f(mins[0], mins[1], mins[2]);
qglVertex3f(mins[0], mins[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], maxs[2]);
qglVertex3f(mins[0], maxs[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], maxs[2]);
qglVertex3f(maxs[0], mins[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], maxs[2]);
qglVertex3f(maxs[0], maxs[1], mins[2]);
qglEnd();
center[0] = (mins[0] + maxs[0]) * 0.5;
center[1] = (mins[1] + maxs[1]) * 0.5;
center[2] = (mins[2] + maxs[2]) * 0.5;
// center axis
qglBegin(GL_LINES);
qglColor3f(1, 0.85, 0);
qglVertex3f(mins[0], center[1], center[2]);
qglVertex3f(maxs[0], center[1], center[2]);
qglVertex3f(center[0], mins[1], center[2]);
qglVertex3f(center[0], maxs[1], center[2]);
qglVertex3f(center[0], center[1], mins[2]);
qglVertex3f(center[0], center[1], maxs[2]);
qglEnd();
}
void CRainSystem::Render(void)
{
int i;
SParticle *item;
vec4_t forward, down, left;
vec3_t pos;
// float percent;
float radius;
CWorldEffectsSystem::Render();
if (mFadeAlpha <= 0.0)
{
return;
}
VectorScale(backEnd.viewParms.or.axis[0], 1, forward); // forward
VectorScale(backEnd.viewParms.or.axis[1], 0.2f, left); // left
down[0] = 0 - mWindDirection[0] * mRainHeight * mWindAngle;
down[1] = 0 - mWindDirection[1] * mRainHeight * mWindAngle;
down[2] = -mRainHeight;
GL_Bind(mImage);
GL_State(GLS_ALPHA);
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_CULL_FACE);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]);
item = mRainList;
qglBegin(GL_TRIANGLES );
for(i=mMaxRain;i;i--)
{
/* percent = (item->pos[1] -(-20.0)) / (20.0 - (-20.0));
percent *= forward[2];
if (percent < 0.0)
{
radius = 10 * (percent + 1.0);
}
else
{
radius = 10 * (1.0 - percent);
}*/
radius = item->pos[1];
if (item->pos[2] < 0.0)
{
// radius *= 1.0 - (item->pos[2] / 40.0);
float alpha = mAlpha * (item->pos[1] / -item->pos[2]);
if (alpha > mAlpha)
{
alpha = mAlpha;
}
qglColor4f(1.0, 1.0, 1.0, alpha * mFadeAlpha);
}
else
{
qglColor4f(1.0, 1.0, 1.0, mAlpha * mFadeAlpha);
// radius *= 1.0 + (item->pos[2] / 20.0);
}
pos[0] = sin(item->pos[0]) * radius + (item->pos[2] * mWindDirection[0] * mWindAngle);
pos[1] = cos(item->pos[0]) * radius + (item->pos[2] * mWindDirection[1] * mWindAngle);
pos[2] = item->pos[2];
qglTexCoord2f(1.0, 0.0);
qglVertex3f(pos[0],
pos[1],
pos[2]);
qglTexCoord2f(0.0, 0.0);
qglVertex3f(pos[0] + left[0],
pos[1] + left[1],
pos[2] + left[2]);
qglTexCoord2f(0.0, 1.0);
qglVertex3f(pos[0] + down[0] + left[0],
pos[1] + down[1] + left[1],
pos[2] + down[2] + left[2]);
item++;
}
qglEnd();
qglEnable(GL_CULL_FACE);
qglPopMatrix();
}
/*
==============
RenderBumpFlat_f
==============
*/
void RenderBumpFlat_f( const idCmdArgs &args ) {
int width, height;
idStr source;
int i;
idBounds bounds;
srfTriangles_t *mesh;
// update the screen as we print
common->SetRefreshOnPrint( true );
width = height = 256;
// 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" );
return;
}
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 );
c = width * height;
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
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." );
}
void DrawTerrain( terrainMesh_t *pm, bool bPoints, bool bShade ) {
int i;
int w;
int h;
int x;
int y;
//int n;
//float x1;
//float y1;
float scale_x;
float scale_y;
//vec3_t pSelectedPoints[ MAX_TERRA_POINTS ];
//int nIndex;
terravert_t a0;
terravert_t a1;
terravert_t a2;
terravert_t b0;
terravert_t b1;
terravert_t b2;
terrainVert_t *vert;
qtexture_t *texture;
h = pm->height - 1;
w = pm->width - 1;
scale_x = pm->scale_x;
scale_y = pm->scale_y;
qglShadeModel (GL_SMOOTH);
if ( bShade ) {
for( i = 0; i < pm->numtextures; i++ ) {
texture = pm->textures[ i ];
qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
vert = pm->heightmap;
for( y = 0; y < h; y++ ) {
qglBegin( GL_TRIANGLES );
for( x = 0; x < w; x++, vert++ ) {
Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
// first tri
if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
qglColor4fv( a0.rgba );
qglTexCoord2fv( a0.tc );
qglVertex3fv( a0.xyz );
qglColor4fv( a1.rgba );
qglTexCoord2fv( a1.tc );
qglVertex3fv( a1.xyz );
qglColor4fv( a2.rgba );
qglTexCoord2fv( a2.tc );
qglVertex3fv( a2.xyz );
}
// second tri
if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
qglColor4fv( b0.rgba );
qglTexCoord2fv( b0.tc );
qglVertex3fv( b0.xyz );
qglColor4fv( b1.rgba );
qglTexCoord2fv( b1.tc );
qglVertex3fv( b1.xyz );
qglColor4fv( b2.rgba );
qglTexCoord2fv( b2.tc );
qglVertex3fv( b2.xyz );
}
}
qglEnd ();
}
}
} else {
for( i = 0; i < pm->numtextures; i++ ) {
texture = pm->textures[ i ];
qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
vert = pm->heightmap;
for( y = 0; y < h; y++ ) {
qglBegin( GL_TRIANGLES );
for( x = 0; x < w; x++, vert++ ) {
Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
// first tri
if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
qglColor4fv( a0.rgba );
qglTexCoord2fv( a0.tc );
qglVertex3fv( a0.xyz );
qglColor4fv( a1.rgba );
qglTexCoord2fv( a1.tc );
qglVertex3fv( a1.xyz );
qglColor4fv( a2.rgba );
qglTexCoord2fv( a2.tc );
qglVertex3fv( a2.xyz );
}
// second tri
if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
qglColor4fv( b0.rgba );
qglTexCoord2fv( b0.tc );
qglVertex3fv( b0.xyz );
qglColor4fv( b1.rgba );
qglTexCoord2fv( b1.tc );
qglVertex3fv( b1.xyz );
qglColor4fv( b2.rgba );
qglTexCoord2fv( b2.tc );
qglVertex3fv( b2.xyz );
}
}
qglEnd ();
}
}
}
qglPushAttrib( GL_CURRENT_BIT );
bool bDisabledLighting = qglIsEnabled( GL_LIGHTING );
if ( bDisabledLighting ) {
qglDisable( GL_LIGHTING );
}
#if 0
terrainVert_t *currentrow;
terrainVert_t *nextrow;
float x2;
float y2;
// Draw normals
qglDisable( GL_TEXTURE_2D );
qglDisable( GL_BLEND );
qglColor3f( 1, 1, 1 );
qglBegin( GL_LINES );
y2 = pm->origin[ 1 ];
nextrow = pm->heightmap;
for( y = 0; y < h; y++ ) {
y1 = y2;
y2 += scale_y;
x2 = pm->origin[ 0 ];
currentrow = nextrow;
nextrow = currentrow + pm->width;
for( x = 0; x < w; x++ ) {
x1 = x2;
x2 += scale_x;
// normals
qglVertex3f( x1, y1, pm->origin[ 2 ] + currentrow[ x ].height );
qglVertex3f( x1 + currentrow[ x ].normal[ 0 ] * 16.0f, y1 + currentrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x ].height + currentrow[ x ].normal[ 2 ] * 16.0f );
qglVertex3f( x2, y1, pm->origin[ 2 ] + currentrow[ x + 1 ].height );
qglVertex3f( x2 + currentrow[ x + 1 ].normal[ 0 ] * 16.0f, y1 + currentrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x + 1 ].height + currentrow[ x + 1 ].normal[ 2 ] * 16.0f );
qglVertex3f( x1, y2, pm->origin[ 2 ] + nextrow[ x ].height );
qglVertex3f( x1 + nextrow[ x ].normal[ 0 ] * 16.0f, y2 + nextrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x ].height + nextrow[ x ].normal[ 2 ] * 16.0f );
qglVertex3f( x2, y2, pm->origin[ 2 ] + nextrow[ x + 1 ].height );
qglVertex3f( x2 + nextrow[ x + 1 ].normal[ 0 ] * 16.0f, y2 + nextrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x + 1 ].height + nextrow[ x + 1 ].normal[ 2 ] * 16.0f );
}
}
qglEnd ();
qglEnable( GL_TEXTURE_2D );
#endif
#if 0
if ( bPoints && ( g_qeglobals.d_select_mode == sel_terrainpoint || g_qeglobals.d_select_mode == sel_area ) ) {
qglPointSize( 6 );
qglDisable( GL_TEXTURE_2D );
qglDisable( GL_BLEND );
qglBegin( GL_POINTS );
nIndex = 0;
qglColor4f( 1, 0, 1, 1 );
y1 = pm->origin[ 1 ];
for ( y = 0; y < pm->height; y++, y1 += pm->scale_y ) {
x1 = pm->origin[ 0 ];
for( x = 0; x < pm->width; x++, x1 += pm->scale_x ) {
// FIXME: need to not do loop lookups inside here
n = Terrain_PointInMoveList( &pm->heightmap[ x + y * pm->width ] );
if ( n >= 0 ) {
VectorSet( pSelectedPoints[ nIndex ], x1, y1, pm->heightmap[ x + y * pm->width ].height + pm->origin[ 2 ] );
nIndex++;
} else {
qglVertex3f( x1, y1, pm->origin[ 2 ] + pm->heightmap[ x + y * pm->width ].height );
}
}
}
qglEnd();
qglEnable( GL_TEXTURE_2D );
if ( nIndex > 0 ) {
qglBegin( GL_POINTS );
qglColor4f( 0, 0, 1, 1 );
while( nIndex-- > 0 ) {
qglVertex3fv( pSelectedPoints[ nIndex ] );
}
qglEnd();
}
}
#endif
if ( g_qeglobals.d_numterrapoints && ( ( g_qeglobals.d_select_mode == sel_terrainpoint ) || ( g_qeglobals.d_select_mode == sel_terraintexture ) ) ) {
#if 0
qglPointSize( 6 );
qglDisable( GL_TEXTURE_2D );
qglDisable( GL_BLEND );
qglBegin( GL_POINTS );
qglColor4f( 1, 0, 1, 1 );
for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
qglVertex3fv( g_qeglobals.d_terrapoints[ i ]->xyz );
}
qglEnd();
qglEnable( GL_TEXTURE_2D );
#endif
brush_t *pb;
terrainMesh_t *pm;
pm = NULL;
for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
if ( pb->terrainBrush ) {
pm = pb->pTerrain;
break;
}
}
if ( pm ) {
qglDisable( GL_TEXTURE_2D );
qglBegin( GL_TRIANGLES );
qglEnable( GL_BLEND );
qglColor4f( 0.25, 0.5, 1, 0.35 );
for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
terravert_t a0;
terravert_t a1;
terravert_t a2;
qglColor4f( 0.25, 0.5, 1, g_qeglobals.d_terrapoints[ i ]->scale * 0.75 + 0.25 );
Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2, &a0, &a1, &a2 );
qglVertex3fv( a0.xyz );
qglVertex3fv( a1.xyz );
qglVertex3fv( a2.xyz );
Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2 + 1, &a0, &a1, &a2 );
qglVertex3fv( a0.xyz );
qglVertex3fv( a1.xyz );
qglVertex3fv( a2.xyz );
}
qglEnd();
qglDisable( GL_BLEND );
qglEnable( GL_TEXTURE_2D );
}
}
}
