803 lines
24 KiB
C++
Executable File
803 lines
24 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "interior/interior.h"
|
|
#include "console/console.h"
|
|
#include "core/color.h"
|
|
#include "dgl/gTexManager.h"
|
|
#include "dgl/dgl.h"
|
|
#include "math/mMatrix.h"
|
|
#include "dgl/materialList.h"
|
|
#include "dgl/gBitmap.h"
|
|
|
|
extern U16* sgActivePolyList;
|
|
extern U32 sgActivePolyListSize;
|
|
|
|
namespace {
|
|
|
|
void lineLoopFromStrip(Vector<ItrPaddedPoint>& points,
|
|
Vector<U32>& windings,
|
|
U32 windingStart,
|
|
U32 windingCount)
|
|
{
|
|
glBegin(GL_LINE_LOOP);
|
|
glVertex3fv(points[windings[windingStart]].point);
|
|
|
|
S32 skip = windingStart + 1;
|
|
while (skip < (windingStart + windingCount)) {
|
|
glVertex3fv(points[windings[skip]].point);
|
|
skip += 2;
|
|
}
|
|
|
|
skip -= 1;
|
|
while (skip > windingStart) {
|
|
if (skip < (windingStart + windingCount))
|
|
glVertex3fv(points[windings[skip]].point);
|
|
skip -= 2;
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
void lineStrip(Vector<ItrPaddedPoint>& points,
|
|
Vector<U32>& windings,
|
|
U32 windingStart,
|
|
U32 windingCount)
|
|
{
|
|
U32 end = 2;
|
|
|
|
while (end < windingCount) {
|
|
// Even
|
|
glBegin(GL_LINE_LOOP);
|
|
glVertex3fv(points[windings[windingStart + end - 2]].point);
|
|
glVertex3fv(points[windings[windingStart + end - 1]].point);
|
|
glVertex3fv(points[windings[windingStart + end - 0]].point);
|
|
glEnd();
|
|
|
|
end++;
|
|
if (end >= windingCount)
|
|
break;
|
|
|
|
glBegin(GL_LINE_LOOP);
|
|
glVertex3fv(points[windings[windingStart + end - 1]].point);
|
|
glVertex3fv(points[windings[windingStart + end - 2]].point);
|
|
glVertex3fv(points[windings[windingStart + end - 0]].point);
|
|
glEnd();
|
|
end++;
|
|
}
|
|
}
|
|
|
|
} // namespace {}
|
|
|
|
|
|
void Interior::debugRender(MaterialList* pMaterials, LM_HANDLE instanceHandle)
|
|
{
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(3, GL_FLOAT, sizeof(ItrPaddedPoint), mPoints.address());
|
|
|
|
switch (smRenderMode) {
|
|
case NormalRenderLines:
|
|
debugNormalRenderLines();
|
|
break;
|
|
|
|
case ShowDetail:
|
|
debugShowDetail();
|
|
break;
|
|
|
|
case ShowAmbiguous:
|
|
debugShowAmbiguous();
|
|
break;
|
|
|
|
case ShowLightmaps:
|
|
debugShowLightmaps(instanceHandle);
|
|
break;
|
|
|
|
case ShowPortalZones:
|
|
debugShowPortalZones();
|
|
break;
|
|
|
|
case ShowCollisionFans:
|
|
debugShowCollisionFans();
|
|
break;
|
|
|
|
case ShowOrphan:
|
|
debugShowOrphan();
|
|
break;
|
|
|
|
case ShowStrips:
|
|
debugShowStrips();
|
|
break;
|
|
|
|
case ShowTexturesOnly:
|
|
debugShowTexturesOnly(pMaterials);
|
|
break;
|
|
|
|
case ShowNullSurfaces:
|
|
debugShowNullSurfaces(pMaterials);
|
|
break;
|
|
|
|
case ShowLargeTextures:
|
|
debugShowLargeTextures(pMaterials);
|
|
break;
|
|
|
|
case ShowOutsideVisible:
|
|
debugShowOutsideVisible();
|
|
break;
|
|
|
|
case ShowHullSurfaces:
|
|
debugShowHullSurfaces();
|
|
break;
|
|
|
|
case ShowVehicleHullSurfaces:
|
|
debugShowVehicleHullSurfaces(pMaterials);
|
|
break;
|
|
|
|
case ShowVertexColors:
|
|
// debugShowVertexColors(pMaterials);
|
|
break;
|
|
|
|
case ShowDetailLevel:
|
|
debugShowDetailLevel();
|
|
break;
|
|
|
|
default:
|
|
AssertWarn(false, "Warning! Misunderstood debug render mode. Defaulting to ShowDetail");
|
|
debugShowDetail();
|
|
break;
|
|
}
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
|
|
void Interior::debugNormalRenderLines()
|
|
{
|
|
// Ok, our verts are set up, draw our polys.
|
|
U32 currentlyBound = U32(-1);
|
|
U32 currentTexGen = U32(-1);
|
|
|
|
// Base textures
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glColor3f(1, 0, 1);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
void Interior::debugShowDetail()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (rSurface.surfaceFlags & SurfaceDetail)
|
|
glColor3f(1.0f, 0, 0);
|
|
else {
|
|
if (smFocusedDebug == true)
|
|
continue;
|
|
else
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
if (smFocusedDebug == false) {
|
|
glColor3f(0, 0, 0);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
void Interior::debugShowAmbiguous()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (rSurface.surfaceFlags & SurfaceAmbiguous)
|
|
glColor3f(0, 1.0f, 0);
|
|
else {
|
|
if (smFocusedDebug == true)
|
|
continue;
|
|
else
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
if (smFocusedDebug == false) {
|
|
glColor3f(0, 0, 0);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
void Interior::debugShowLightmaps(LM_HANDLE instanceHandle)
|
|
{
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
U32 currentlyBound = U32(-1);
|
|
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (mNormalLMapIndices[sgActivePolyList[i]] != currentlyBound) {
|
|
glBindTexture(GL_TEXTURE_2D, gInteriorLMManager.getHandle(mLMHandle, instanceHandle, mNormalLMapIndices[sgActivePolyList[i]])->getGLName());
|
|
currentlyBound = mNormalLMapIndices[sgActivePolyList[i]];
|
|
}
|
|
|
|
// Draw the poly
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++) {
|
|
glTexCoord2f(mLMTexGenEQs[sgActivePolyList[i]].planeX.distToPlane(mPoints[mWindings[j]].point),
|
|
mLMTexGenEQs[sgActivePolyList[i]].planeY.distToPlane(mPoints[mWindings[j]].point));
|
|
glVertex3fv(mPoints[mWindings[j]].point);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glColor3f(0, 0, 0);
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
renderStaticMeshes(false, true, instanceHandle);
|
|
}
|
|
|
|
|
|
void Interior::debugShowPortalZones()
|
|
{
|
|
static U8 colors[14][3] = {
|
|
{ 0xFF, 0xFF, 0xFF },
|
|
{ 0x00, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0x00 },
|
|
{ 0xFF, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0xFF },
|
|
{ 0x80, 0x80, 0x80 },
|
|
{ 0xFF, 0x80, 0x80 },
|
|
{ 0x80, 0xFF, 0x80 },
|
|
{ 0x80, 0x80, 0xFF },
|
|
{ 0x80, 0xFF, 0xFF },
|
|
{ 0xFF, 0x80, 0xFF },
|
|
{ 0xFF, 0x80, 0x80 }
|
|
};
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
for (U32 i = 0; i < mZones.size(); i++) {
|
|
U8* color;
|
|
if (i == 0)
|
|
color = colors[0];
|
|
else
|
|
color = colors[(i % 13) + 1];
|
|
|
|
for (U32 j = mZones[i].surfaceStart; j < mZones[i].surfaceStart + mZones[i].surfaceCount; j++) {
|
|
const Surface& rSurface = mSurfaces[mZoneSurfaces[j]];
|
|
|
|
glColor3ub(color[0], color[1], color[2]);
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
glColor3ub(0, 0, 0);
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
debugRenderPortals();
|
|
}
|
|
|
|
void Interior::debugRenderPortals()
|
|
{
|
|
//-------------------------------------- Render portals...
|
|
glDisable(GL_TEXTURE_2D);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
for (U32 i = 0; i < mPortals.size(); i++) {
|
|
const Portal& rPortal = mPortals[i];
|
|
|
|
for (U16 j = 0; j < rPortal.triFanCount; j++) {
|
|
const TriFan& rFan = mWindingIndices[rPortal.triFanStart + j];
|
|
U32 k;
|
|
|
|
glColor4f(0.75, 0.5, 0.75, 0.45);
|
|
glBegin(GL_TRIANGLE_FAN);
|
|
for (k = 0; k < rFan.windingCount; k++)
|
|
glVertex3fv(mPoints[mWindings[rFan.windingStart + k]].point);
|
|
glEnd();
|
|
glColor4f(0, 0, 1, 1);
|
|
glBegin(GL_LINE_LOOP);
|
|
for (k = 0; k < rFan.windingCount; k++)
|
|
glVertex3fv(mPoints[mWindings[rFan.windingStart + k]].point);
|
|
glEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Interior::debugShowCollisionFans()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 numIndices;
|
|
U32 fanIndices[32];
|
|
collisionFanFromSurface(rSurface, fanIndices, &numIndices);
|
|
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
glDrawElements(GL_TRIANGLE_FAN, numIndices, GL_UNSIGNED_INT, fanIndices);
|
|
}
|
|
|
|
glColor3f(0, 0, 0);
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 numIndices;
|
|
U32 fanIndices[32];
|
|
collisionFanFromSurface(rSurface, fanIndices, &numIndices);
|
|
glBegin(GL_LINE_LOOP);
|
|
for (U32 j = 0; j < numIndices; j++)
|
|
glVertex3fv(mPoints[fanIndices[j]].point);
|
|
glEnd();
|
|
}
|
|
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 numIndices;
|
|
U32 fanIndices[32];
|
|
collisionFanFromSurface(rSurface, fanIndices, &numIndices);
|
|
|
|
glColor3f(1, 0, 0);
|
|
glBegin(GL_LINES);
|
|
for (U32 j = 0; j < numIndices; j++) {
|
|
Point3F up = mPoints[fanIndices[j]].point;
|
|
Point3F norm = getPlane(rSurface.planeIndex);
|
|
if (planeIsFlipped(rSurface.planeIndex))
|
|
up -= norm * 0.4;
|
|
else
|
|
up += norm * 0.4;
|
|
|
|
glVertex3fv(mPoints[fanIndices[j]].point);
|
|
glVertex3fv(up);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void Interior::debugShowOrphan()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (rSurface.surfaceFlags & SurfaceOrphan)
|
|
glColor3f(0.0f, 0.0f, 1.0f);
|
|
else {
|
|
if (smFocusedDebug == true)
|
|
continue;
|
|
else
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
if (smFocusedDebug == false) {
|
|
glColor3f(0, 0, 0);
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void Interior::debugShowOrphansFinish()
|
|
{
|
|
|
|
}
|
|
|
|
void Interior::debugShowStrips()
|
|
{
|
|
static U8 colors[14][3] = {
|
|
{ 0xFF, 0xFF, 0xFF },
|
|
{ 0x00, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0x00 },
|
|
{ 0xFF, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0xFF },
|
|
{ 0x80, 0x80, 0x80 },
|
|
{ 0xFF, 0x80, 0x80 },
|
|
{ 0x80, 0xFF, 0x80 },
|
|
{ 0x80, 0x80, 0xFF },
|
|
{ 0x80, 0xFF, 0xFF },
|
|
{ 0xFF, 0x80, 0xFF },
|
|
{ 0xFF, 0x80, 0x80 }
|
|
};
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
U32 color = 0;
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
glColor3ub(colors[sgActivePolyList[i]%14][0],
|
|
colors[sgActivePolyList[i]%14][1],
|
|
colors[sgActivePolyList[i]%14][2]);
|
|
color++;
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
glColor3f(0, 0, 0);
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
void Interior::debugShowNullSurfaces(MaterialList* pMaterials)
|
|
{
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
// Base textures
|
|
U32 currentlyBound = U32(-1);
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 baseName = pMaterials->getMaterial(rSurface.textureIndex).getGLName();
|
|
if (baseName != currentlyBound) {
|
|
glBindTexture(GL_TEXTURE_2D, baseName);
|
|
currentlyBound = baseName;
|
|
}
|
|
|
|
// Draw the poly
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++) {
|
|
glTexCoord2f(mTexGenEQs[rSurface.texGenIndex].planeX.distToPlane(mPoints[mWindings[j]].point),
|
|
mTexGenEQs[rSurface.texGenIndex].planeY.distToPlane(mPoints[mWindings[j]].point));
|
|
glVertex3fv(mPoints[mWindings[j]].point);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
glColor3f(1, 0, 0);
|
|
for (i = 0; i < mNullSurfaces.size(); i++) {
|
|
const NullSurface& rSurface = mNullSurfaces[i];
|
|
|
|
glDrawElements(GL_TRIANGLE_FAN, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void Interior::debugShowTexturesOnly(MaterialList* pMaterials)
|
|
{
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
// Base textures
|
|
U32 currentlyBound = U32(-1);
|
|
U32 i;
|
|
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (pMaterials->getMaterial(rSurface.textureIndex).getGLName() != currentlyBound) {
|
|
glBindTexture(GL_TEXTURE_2D, pMaterials->getMaterial(rSurface.textureIndex).getGLName());
|
|
currentlyBound = mMaterialList->getMaterial(rSurface.textureIndex).getGLName();
|
|
}
|
|
|
|
// Draw the poly
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++) {
|
|
glTexCoord2f(mTexGenEQs[rSurface.texGenIndex].planeX.distToPlane(mPoints[mWindings[j]].point),
|
|
mTexGenEQs[rSurface.texGenIndex].planeY.distToPlane(mPoints[mWindings[j]].point));
|
|
glVertex3fv(mPoints[mWindings[j]].point);
|
|
}
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
void Interior::debugShowLargeTextures(MaterialList* pMaterials)
|
|
{
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
|
|
// Base textures
|
|
U32 currentlyBound = U32(-1);
|
|
U32 currentTexGen = U32(-1);
|
|
U32 i;
|
|
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 baseName = pMaterials->getMaterial(rSurface.textureIndex).getGLName();
|
|
if (baseName != currentlyBound) {
|
|
glBindTexture(GL_TEXTURE_2D, baseName);
|
|
currentlyBound = baseName;
|
|
|
|
U32 width = pMaterials->getMaterial(rSurface.textureIndex).getWidth();
|
|
U32 height = pMaterials->getMaterial(rSurface.textureIndex).getHeight();
|
|
if (width >= 256 || height >= 256) {
|
|
if (width == 256 && height == 256) {
|
|
// small large
|
|
glColor3f(0.25, 0.25, 1);
|
|
} else if (width != 512 || height != 512) {
|
|
// thin large
|
|
glColor3f(0.25, 1, 0.25);
|
|
} else {
|
|
// oh god.
|
|
glColor3f(1, 0.25, 0.25);
|
|
}
|
|
} else {
|
|
glColor3f(0.35, 0.35, 0.35);
|
|
}
|
|
}
|
|
|
|
// Draw the poly
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++) {
|
|
glTexCoord2f(mTexGenEQs[rSurface.texGenIndex].planeX.distToPlane(mPoints[mWindings[j]].point),
|
|
mTexGenEQs[rSurface.texGenIndex].planeY.distToPlane(mPoints[mWindings[j]].point));
|
|
glVertex3fv(mPoints[mWindings[j]].point);
|
|
}
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
|
|
void Interior::debugShowOutsideVisible()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
if (rSurface.surfaceFlags & SurfaceOutsideVisible)
|
|
glColor3f(1.0f, 0, 0);
|
|
else {
|
|
if (smFocusedDebug == true)
|
|
continue;
|
|
else
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
if (smFocusedDebug == false) {
|
|
glColor3f(0, 0, 0);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void Interior::debugShowHullSurfaces()
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
static U8 colors[14][3] = {
|
|
{ 0xFF, 0xFF, 0xFF },
|
|
{ 0x00, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0x00 },
|
|
{ 0xFF, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0xFF },
|
|
{ 0x80, 0x80, 0x80 },
|
|
{ 0xFF, 0x80, 0x80 },
|
|
{ 0x80, 0xFF, 0x80 },
|
|
{ 0x80, 0x80, 0xFF },
|
|
{ 0x80, 0xFF, 0xFF },
|
|
{ 0xFF, 0x80, 0xFF },
|
|
{ 0xFF, 0x80, 0x80 }
|
|
};
|
|
U32 color = 0;
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
for (U32 i = 0; i < mConvexHulls.size(); i++) {
|
|
const ConvexHull& rHull = mConvexHulls[i];
|
|
for (U32 j = rHull.surfaceStart; j < rHull.surfaceCount + rHull.surfaceStart; j++) {
|
|
U32 index = mHullSurfaceIndices[j];
|
|
if (isNullSurfaceIndex(index)) {
|
|
} else {
|
|
const Interior::Surface& rSurface = mSurfaces[index];
|
|
U32 fanVerts[32];
|
|
U32 numVerts;
|
|
collisionFanFromSurface(rSurface, fanVerts, &numVerts);
|
|
|
|
glColor3ub(colors[(i%13)+1][0], colors[(i%13)+1][1], colors[(i%13)+1][2]);
|
|
color++;
|
|
Point3F center(0, 0, 0);
|
|
glBegin(GL_TRIANGLE_FAN);
|
|
for (U32 k = 0; k < numVerts; k++) {
|
|
glVertex3fv(mPoints[fanVerts[k]].point);
|
|
center += mPoints[fanVerts[k]].point;
|
|
}
|
|
glEnd();
|
|
center /= F32(numVerts);
|
|
glColor3f(0, 0, 0);
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
|
|
PlaneF plane;
|
|
plane.set(mPoints[fanVerts[0]].point, mPoints[fanVerts[1]].point, mPoints[fanVerts[2]].point);
|
|
glBegin(GL_LINES);
|
|
glVertex3fv(center);
|
|
glVertex3fv(center + (plane * 0.25));
|
|
glEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void Interior::debugShowVehicleHullSurfaces(MaterialList* pMaterials)
|
|
{
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
// Base textures
|
|
U32 currentlyBound = U32(-1);
|
|
U32 i;
|
|
for (i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
U32 baseName = pMaterials->getMaterial(rSurface.textureIndex).getGLName();
|
|
if (baseName != currentlyBound) {
|
|
glBindTexture(GL_TEXTURE_2D, baseName);
|
|
currentlyBound = baseName;
|
|
}
|
|
|
|
// Draw the poly
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++) {
|
|
glTexCoord2f(mTexGenEQs[rSurface.texGenIndex].planeX.distToPlane(mPoints[mWindings[j]].point),
|
|
mTexGenEQs[rSurface.texGenIndex].planeY.distToPlane(mPoints[mWindings[j]].point));
|
|
glVertex3fv(mPoints[mWindings[j]].point);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
glVertexPointer(3, GL_FLOAT, sizeof(ItrPaddedPoint), mVehiclePoints.address());
|
|
|
|
glColor3f(1, 0, 0);
|
|
for (i = 0; i < mVehicleNullSurfaces.size(); i++) {
|
|
const NullSurface& rSurface = mNullSurfaces[i];
|
|
|
|
glDrawElements(GL_TRIANGLE_FAN, rSurface.windingCount, GL_UNSIGNED_INT, &mVehicleWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
// void Interior::debugShowVertexColors(MaterialList* /*pMaterials*/)
|
|
// {
|
|
// glDisable(GL_TEXTURE_2D);
|
|
// glBlendFunc(GL_ONE, GL_ZERO);
|
|
|
|
// for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
// const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
// glBegin(GL_TRIANGLE_STRIP);
|
|
// for (U32 j = rSurface.windingStart; j < rSurface.windingStart + rSurface.windingCount; j++)
|
|
// {
|
|
// const ItrPaddedPoint& rPoint = mPoints[mWindings[j]];
|
|
// glColor3ub(mVertexColorsNormal[j].red,
|
|
// mVertexColorsNormal[j].green,
|
|
// mVertexColorsNormal[j].blue);
|
|
// glVertex3fv(rPoint.point);
|
|
// }
|
|
// glEnd();
|
|
// }
|
|
|
|
// if (smFocusedDebug == false) {
|
|
// glColor3f(0, 0, 0);
|
|
// for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
// const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
// lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
// }
|
|
// }
|
|
|
|
// glEnable(GL_TEXTURE_2D);
|
|
// }
|
|
|
|
|
|
void Interior::debugShowDetailLevel()
|
|
{
|
|
static U8 colors[14][3] = {
|
|
{ 0xFF, 0xFF, 0xFF },
|
|
{ 0x00, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0x00 },
|
|
{ 0xFF, 0xFF, 0x00 },
|
|
{ 0xFF, 0x00, 0xFF },
|
|
{ 0x00, 0xFF, 0xFF },
|
|
{ 0x80, 0x80, 0x80 },
|
|
{ 0xFF, 0x80, 0x80 },
|
|
{ 0x80, 0xFF, 0x80 },
|
|
{ 0x80, 0x80, 0xFF },
|
|
{ 0x80, 0xFF, 0xFF },
|
|
{ 0xFF, 0x80, 0xFF },
|
|
{ 0xFF, 0x80, 0x80 }
|
|
};
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
|
|
glColor3ubv(colors[getDetailLevel()]);
|
|
glDrawElements(GL_TRIANGLE_STRIP, rSurface.windingCount, GL_UNSIGNED_INT, &mWindings[rSurface.windingStart]);
|
|
}
|
|
|
|
if (smFocusedDebug == false) {
|
|
glColor3f(0, 0, 0);
|
|
for (U32 i = 0; i < sgActivePolyListSize; i++) {
|
|
const Surface& rSurface = mSurfaces[sgActivePolyList[i]];
|
|
lineLoopFromStrip(mPoints, mWindings, rSurface.windingStart, rSurface.windingCount);
|
|
}
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|