/*
================
DrawNormals
Draws vertex normals for debugging
================
*/
static void DrawNormals( shaderCommands_t *input ) {
int i;
vec3_t temp;
GL_Bind( tr.whiteImage );
qglColor3f( 1,1,1 );
qglDepthRange( 0, 0 ); // never occluded
GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
// ydnar: light direction
if ( r_shownormals->integer == 2 ) {
trRefEntity_t *ent = backEnd.currentEntity;
vec3_t temp2;
if ( ent->e.renderfx & RF_LIGHTING_ORIGIN ) {
VectorSubtract( ent->e.lightingOrigin, backEnd.orientation.origin, temp2 );
} else {
VectorClear( temp2 );
}
temp[ 0 ] = DotProduct( temp2, backEnd.orientation.axis[ 0 ] );
temp[ 1 ] = DotProduct( temp2, backEnd.orientation.axis[ 1 ] );
temp[ 2 ] = DotProduct( temp2, backEnd.orientation.axis[ 2 ] );
qglColor3f( ent->ambientLight[ 0 ] / 255, ent->ambientLight[ 1 ] / 255, ent->ambientLight[ 2 ] / 255 );
qglPointSize( 5 );
qglBegin( GL_POINTS );
qglVertex3fv( temp );
qglEnd();
qglPointSize( 1 );
if ( fabs( VectorLengthSquared( ent->lightDir ) - 1.0f ) > 0.2f ) {
qglColor3f( 1, 0, 0 );
} else {
qglColor3f( ent->directedLight[ 0 ] / 255, ent->directedLight[ 1 ] / 255, ent->directedLight[ 2 ] / 255 );
}
qglLineWidth( 3 );
qglBegin( GL_LINES );
qglVertex3fv( temp );
VectorMA( temp, 32, ent->lightDir, temp );
qglVertex3fv( temp );
qglEnd();
qglLineWidth( 1 );
}
// ydnar: normals drawing
else
{
qglBegin( GL_LINES );
for ( i = 0 ; i < input->numVertexes ; i++ ) {
qglVertex3fv( input->xyz[i].v );
VectorMA( input->xyz[i].v, r_normallength->value, input->normal[i].v, temp );
qglVertex3fv( temp );
}
qglEnd();
}
qglDepthRange( 0, 1 );
}
void idSplineList::draw(bool editMode) {
int i;
vec4_t yellow(1, 1, 0, 1);
if (controlPoints.Num() == 0) {
return;
}
if (dirty) {
buildSpline();
}
qglColor3fv(controlColor);
qglPointSize(5);
qglBegin(GL_POINTS);
for (i = 0; i < controlPoints.Num(); i++) {
qglVertex3fv(*controlPoints[i]);
}
qglEnd();
if (editMode) {
for(i = 0; i < controlPoints.Num(); i++) {
glBox(activeColor, *controlPoints[i], 4);
}
}
//Draw the curve
qglColor3fv(pathColor);
qglBegin(GL_LINE_STRIP);
int count = splinePoints.Num();
for (i = 0; i < count; i++) {
qglVertex3fv(*splinePoints[i]);
}
qglEnd();
if (editMode) {
qglColor3fv(segmentColor);
qglPointSize(3);
qglBegin(GL_POINTS);
for (i = 0; i < count; i++) {
qglVertex3fv(*splinePoints[i]);
}
qglEnd();
}
if (count > 0) {
//assert(activeSegment >=0 && activeSegment < count);
if (activeSegment >=0 && activeSegment < count) {
glBox(activeColor, *splinePoints[activeSegment], 6);
glBox(yellow, *splinePoints[activeSegment], 8);
}
}
}
void CSnowSystem::Render(void)
{
int i;
SParticle *item;
vec3_t origin;
if (!(mOverallContents & CONTENTS_OUTSIDE))
{
return;
}
CWorldEffectsSystem::Render();
VectorAdd(backEnd.viewParms.or.origin, mMinSpread, origin);
qglColor4f(0.8f, 0.8f, 0.8f, mAlpha);
// GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_ONE);
GL_State(GLS_ALPHA);
qglDisable(GL_TEXTURE_2D);
if (qglPointParameterfEXT)
{
qglPointSize(10.0);
qglPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, 1.0);
qglPointParameterfEXT(GL_POINT_SIZE_MAX_EXT, 4.0);
// qglPointParameterfEXT(GL_POINT_FADE_THRESHOLD_SIZE_EXT, 3.0);
qglPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, (float *)attenuation);
}
else
{
qglPointSize(2.0);
}
item = mSnowList;
qglBegin(GL_POINTS);
for(i=mMaxSnowflakes;i;i--)
{
if (item->flags & PARTICLE_FLAG_RENDER)
{
qglVertex3fv(item->pos);
}
item++;
}
qglEnd();
qglEnable(GL_TEXTURE_2D);
}
/*
================
glLabeledPoint
================
*/
void glLabeledPoint(idVec4 &color, idVec3 &point, float size, const char *label) {
qglColor3fv( color.ToFloatPtr() );
qglPointSize( size );
qglBegin( GL_POINTS );
qglVertex3fv( point.ToFloatPtr() );
qglEnd();
idVec3 v = point;
v.x += 1;
v.y += 1;
v.z += 1;
qglRasterPos3fv( v.ToFloatPtr() );
qglCallLists( strlen(label), GL_UNSIGNED_BYTE, label );
}
void CWindingMsg::Draw2D( VIEWTYPE vt ){
int i;
int nDim1 = ( vt == YZ ) ? 1 : 0;
int nDim2 = ( vt == XY ) ? 1 : 2;
qglColor3f( 1.0f,0.f,0.0f );
qglPointSize( 4 );
qglBegin( GL_POINTS );
for ( i = 0; i < numpoints; i++ )
qglVertex2f( wt[i][nDim1], wt[i][nDim2] );
qglEnd();
qglPointSize( 1 );
qglEnable( GL_BLEND );
qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
qglColor4f( 0.133f,0.4f,1.0f,0.5f );
qglBegin( GL_POLYGON );
for ( i = 0; i < numpoints; i++ )
qglVertex2f( wt[i][nDim1], wt[i][nDim2] );
qglEnd();
qglDisable( GL_BLEND );
}
void CPointMsg::Draw2D( VIEWTYPE vt ){
int nDim1 = ( vt == YZ ) ? 1 : 0;
int nDim2 = ( vt == XY ) ? 1 : 2;
qglPointSize( 4 );
qglColor3f( 1.0f,0.0f,0.0f );
qglBegin( GL_POINTS );
qglVertex2f( pt[nDim1], pt[nDim2] );
qglEnd();
qglBegin( GL_LINE_LOOP );
qglVertex2f( pt[nDim1] - 8, pt[nDim2] - 8 );
qglVertex2f( pt[nDim1] + 8, pt[nDim2] - 8 );
qglVertex2f( pt[nDim1] + 8, pt[nDim2] + 8 );
qglVertex2f( pt[nDim1] - 8, pt[nDim2] + 8 );
qglEnd();
}
/*
================
DrawVerts
================
*/
static void DrawVerts( optIsland_t *island ) {
optVertex_t *vert;
if ( !dmapGlobals.drawflag ) {
return;
}
qglEnable( GL_BLEND );
qglBlendFunc( GL_ONE, GL_ONE );
qglColor3f( 0.3f, 0.3f, 0.3f );
qglPointSize( 3 );
qglBegin( GL_POINTS );
for ( vert = island->verts ; vert ; vert = vert->islandLink ) {
qglVertex3fv( vert->pv.ToFloatPtr() );
}
qglEnd();
qglDisable( GL_BLEND );
qglFlush();
}
/*
===============
CreateOptTri
===============
*/
static void CreateOptTri( optVertex_t *first, optEdge_t *e1, optEdge_t *e2, optIsland_t *island ) {
optEdge_t *opposite;
optVertex_t *second, *third;
optTri_t *optTri;
mapTri_t *tri;
if ( e1->v1 == first ) {
second = e1->v2;
} else if ( e1->v2 == first ) {
second = e1->v1;
} else {
common->Error( "CreateOptTri: mislinked edge" );
return;
}
if ( e2->v1 == first ) {
third = e2->v2;
} else if ( e2->v2 == first ) {
third = e2->v1;
} else {
common->Error( "CreateOptTri: mislinked edge" );
return;
}
if ( !IsTriangleValid( first, second, third ) ) {
common->Error( "CreateOptTri: invalid" );
return;
}
//DrawEdges( island );
// identify the third edge
if ( dmapGlobals.drawflag ) {
qglColor3f(1,1,0);
qglBegin( GL_LINES );
qglVertex3fv( e1->v1->pv.ToFloatPtr() );
qglVertex3fv( e1->v2->pv.ToFloatPtr() );
qglEnd();
qglFlush();
qglColor3f(0,1,1);
qglBegin( GL_LINES );
qglVertex3fv( e2->v1->pv.ToFloatPtr() );
qglVertex3fv( e2->v2->pv.ToFloatPtr() );
qglEnd();
qglFlush();
}
for ( opposite = second->edges ; opposite ; ) {
if ( opposite != e1 && ( opposite->v1 == third || opposite->v2 == third ) ) {
break;
}
if ( opposite->v1 == second ) {
opposite = opposite->v1link;
} else if ( opposite->v2 == second ) {
opposite = opposite->v2link;
} else {
common->Error( "BuildOptTriangles: mislinked edge" );
return;
}
}
if ( !opposite ) {
common->Printf( "Warning: BuildOptTriangles: couldn't locate opposite\n" );
return;
}
if ( dmapGlobals.drawflag ) {
qglColor3f(1,0,1);
qglBegin( GL_LINES );
qglVertex3fv( opposite->v1->pv.ToFloatPtr() );
qglVertex3fv( opposite->v2->pv.ToFloatPtr() );
qglEnd();
qglFlush();
}
// create new triangle
optTri = (optTri_t *)Mem_Alloc( sizeof( *optTri ), TAG_DMAP );
optTri->v[0] = first;
optTri->v[1] = second;
optTri->v[2] = third;
optTri->midpoint = ( optTri->v[0]->pv + optTri->v[1]->pv + optTri->v[2]->pv ) * ( 1.0f / 3.0f );
optTri->next = island->tris;
island->tris = optTri;
if ( dmapGlobals.drawflag ) {
qglColor3f( 1, 1, 1 );
qglPointSize( 4 );
qglBegin( GL_POINTS );
qglVertex3fv( optTri->midpoint.ToFloatPtr() );
qglEnd();
qglFlush();
}
// find the midpoint, and scan through all the original triangles to
// see if it is inside any of them
for ( tri = island->group->triList ; tri ; tri = tri->next ) {
if ( PointInTri( optTri->midpoint, tri, island ) ) {
break;
}
}
if ( tri ) {
optTri->filled = true;
} else {
optTri->filled = false;
}
if ( dmapGlobals.drawflag ) {
if ( optTri->filled ) {
qglColor3f( ( 128 + orandom.RandomInt( 127 ) )/ 255.0, 0, 0 );
} else {
qglColor3f( 0, ( 128 + orandom.RandomInt( 127 ) ) / 255.0, 0 );
}
qglBegin( GL_TRIANGLES );
qglVertex3fv( optTri->v[0]->pv.ToFloatPtr() );
qglVertex3fv( optTri->v[1]->pv.ToFloatPtr() );
qglVertex3fv( optTri->v[2]->pv.ToFloatPtr() );
qglEnd();
qglColor3f( 1, 1, 1 );
qglBegin( GL_LINE_LOOP );
qglVertex3fv( optTri->v[0]->pv.ToFloatPtr() );
qglVertex3fv( optTri->v[1]->pv.ToFloatPtr() );
qglVertex3fv( optTri->v[2]->pv.ToFloatPtr() );
qglEnd();
qglFlush();
}
// link the triangle to it's edges
LinkTriToEdge( optTri, e1 );
LinkTriToEdge( optTri, e2 );
LinkTriToEdge( optTri, opposite );
}
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)));
}
}
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 );
}
}
}
