mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-14 14:51:10 +00:00
682 lines
16 KiB
C++
682 lines
16 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "dmap.h"
|
|
|
|
//=================================================================================
|
|
|
|
|
|
#if 0
|
|
|
|
should we try and snap values very close to 0.5, 0.25, 0.125, etc?
|
|
|
|
do we write out normals, or just a "smooth shade" flag?
|
|
resolved: normals. otherwise adjacent facet shaded surfaces get their
|
|
vertexes merged, and they would have to be split apart before drawing
|
|
|
|
do we save out "wings" for shadow silhouette info?
|
|
|
|
|
|
#endif
|
|
|
|
static idFile *procFile;
|
|
|
|
#define AREANUM_DIFFERENT -2
|
|
/*
|
|
=============
|
|
PruneNodes_r
|
|
|
|
Any nodes that have all children with the same
|
|
area can be combined into a single leaf node
|
|
|
|
Returns the area number of all children, or
|
|
AREANUM_DIFFERENT if not the same.
|
|
=============
|
|
*/
|
|
int PruneNodes_r( node_t *node ) {
|
|
int a1, a2;
|
|
|
|
if ( node->planenum == PLANENUM_LEAF ) {
|
|
return node->area;
|
|
}
|
|
|
|
a1 = PruneNodes_r( node->children[0] );
|
|
a2 = PruneNodes_r( node->children[1] );
|
|
|
|
if ( a1 != a2 || a1 == AREANUM_DIFFERENT ) {
|
|
return AREANUM_DIFFERENT;
|
|
}
|
|
|
|
// free all the nodes below this point
|
|
FreeTreePortals_r( node->children[0] );
|
|
FreeTreePortals_r( node->children[1] );
|
|
FreeTree_r( node->children[0] );
|
|
FreeTree_r( node->children[1] );
|
|
|
|
// change this node to a leaf
|
|
node->planenum = PLANENUM_LEAF;
|
|
node->area = a1;
|
|
|
|
return a1;
|
|
}
|
|
|
|
static void WriteFloat( idFile *f, float v )
|
|
{
|
|
if ( idMath::Fabs(v - idMath::Rint(v)) < 0.001 ) {
|
|
f->WriteFloatString( "%i ", (int)idMath::Rint(v) );
|
|
}
|
|
else {
|
|
f->WriteFloatString( "%f ", v );
|
|
}
|
|
}
|
|
|
|
void Write1DMatrix( idFile *f, int x, float *m ) {
|
|
int i;
|
|
|
|
f->WriteFloatString( "( " );
|
|
|
|
for ( i = 0; i < x; i++ ) {
|
|
WriteFloat( f, m[i] );
|
|
}
|
|
|
|
f->WriteFloatString( ") " );
|
|
}
|
|
|
|
static int CountUniqueShaders( optimizeGroup_t *groups ) {
|
|
optimizeGroup_t *a, *b;
|
|
int count;
|
|
|
|
count = 0;
|
|
|
|
for ( a = groups ; a ; a = a->nextGroup ) {
|
|
if ( !a->triList ) { // ignore groups with no tris
|
|
continue;
|
|
}
|
|
for ( b = groups ; b != a ; b = b->nextGroup ) {
|
|
if ( !b->triList ) {
|
|
continue;
|
|
}
|
|
if ( a->material != b->material ) {
|
|
continue;
|
|
}
|
|
if ( a->mergeGroup != b->mergeGroup ) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ( a == b ) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
/*
|
|
==============
|
|
MatchVert
|
|
==============
|
|
*/
|
|
#define XYZ_EPSILON 0.01
|
|
#define ST_EPSILON 0.001
|
|
#define COSINE_EPSILON 0.999
|
|
|
|
static bool MatchVert( const idDrawVert *a, const idDrawVert *b ) {
|
|
if ( idMath::Fabs( a->xyz[0] - b->xyz[0] ) > XYZ_EPSILON ) {
|
|
return false;
|
|
}
|
|
if ( idMath::Fabs( a->xyz[1] - b->xyz[1] ) > XYZ_EPSILON ) {
|
|
return false;
|
|
}
|
|
if ( idMath::Fabs( a->xyz[2] - b->xyz[2] ) > XYZ_EPSILON ) {
|
|
return false;
|
|
}
|
|
if ( idMath::Fabs( a->st[0] - b->st[0] ) > ST_EPSILON ) {
|
|
return false;
|
|
}
|
|
if ( idMath::Fabs( a->st[1] - b->st[1] ) > ST_EPSILON ) {
|
|
return false;
|
|
}
|
|
|
|
// if the normal is 0 (smoothed normals), consider it a match
|
|
if ( a->normal[0] == 0 && a->normal[1] == 0 && a->normal[2] == 0
|
|
&& b->normal[0] == 0 && b->normal[1] == 0 && b->normal[2] == 0 ) {
|
|
return true;
|
|
}
|
|
|
|
// otherwise do a dot-product cosine check
|
|
if ( DotProduct( a->normal, b->normal ) < COSINE_EPSILON ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
ShareMapTriVerts
|
|
|
|
Converts independent triangles to shared vertex triangles
|
|
====================
|
|
*/
|
|
srfTriangles_t *ShareMapTriVerts( const mapTri_t *tris ) {
|
|
const mapTri_t *step;
|
|
int count;
|
|
int i, j;
|
|
int numVerts;
|
|
int numIndexes;
|
|
srfTriangles_t *uTri;
|
|
|
|
// unique the vertexes
|
|
count = CountTriList( tris );
|
|
|
|
uTri = R_AllocStaticTriSurf();
|
|
R_AllocStaticTriSurfVerts( uTri, count * 3 );
|
|
R_AllocStaticTriSurfIndexes( uTri, count * 3 );
|
|
|
|
numVerts = 0;
|
|
numIndexes = 0;
|
|
|
|
for ( step = tris ; step ; step = step->next ) {
|
|
for ( i = 0 ; i < 3 ; i++ ) {
|
|
const idDrawVert *dv;
|
|
|
|
dv = &step->v[i];
|
|
|
|
// search for a match
|
|
for ( j = 0 ; j < numVerts ; j++ ) {
|
|
if ( MatchVert( &uTri->verts[j], dv ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( j == numVerts ) {
|
|
numVerts++;
|
|
uTri->verts[j].xyz = dv->xyz;
|
|
uTri->verts[j].normal = dv->normal;
|
|
uTri->verts[j].st[0] = dv->st[0];
|
|
uTri->verts[j].st[1] = dv->st[1];
|
|
}
|
|
|
|
uTri->indexes[numIndexes++] = j;
|
|
}
|
|
}
|
|
|
|
uTri->numVerts = numVerts;
|
|
uTri->numIndexes = numIndexes;
|
|
|
|
return uTri;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CleanupUTriangles
|
|
==================
|
|
*/
|
|
static void CleanupUTriangles( srfTriangles_t *tri ) {
|
|
// perform cleanup operations
|
|
|
|
R_RangeCheckIndexes( tri );
|
|
R_CreateSilIndexes( tri );
|
|
// R_RemoveDuplicatedTriangles( tri ); // this may remove valid overlapped transparent triangles
|
|
R_RemoveDegenerateTriangles( tri );
|
|
// R_RemoveUnusedVerts( tri );
|
|
|
|
R_FreeStaticTriSurfSilIndexes( tri );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
WriteUTriangles
|
|
|
|
Writes text verts and indexes to procfile
|
|
====================
|
|
*/
|
|
static void WriteUTriangles( const srfTriangles_t *uTris ) {
|
|
int col;
|
|
int i;
|
|
|
|
// emit this chain
|
|
procFile->WriteFloatString( "/* numVerts = */ %i /* numIndexes = */ %i\n",
|
|
uTris->numVerts, uTris->numIndexes );
|
|
|
|
// verts
|
|
col = 0;
|
|
for ( i = 0 ; i < uTris->numVerts ; i++ ) {
|
|
float vec[8];
|
|
const idDrawVert *dv;
|
|
|
|
dv = &uTris->verts[i];
|
|
|
|
vec[0] = dv->xyz[0];
|
|
vec[1] = dv->xyz[1];
|
|
vec[2] = dv->xyz[2];
|
|
vec[3] = dv->st[0];
|
|
vec[4] = dv->st[1];
|
|
vec[5] = dv->normal[0];
|
|
vec[6] = dv->normal[1];
|
|
vec[7] = dv->normal[2];
|
|
Write1DMatrix( procFile, 8, vec );
|
|
|
|
if ( ++col == 3 ) {
|
|
col = 0;
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
if ( col != 0 ) {
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
|
|
// indexes
|
|
col = 0;
|
|
for ( i = 0 ; i < uTris->numIndexes ; i++ ) {
|
|
procFile->WriteFloatString( "%i ", uTris->indexes[i] );
|
|
|
|
if ( ++col == 18 ) {
|
|
col = 0;
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
if ( col != 0 ) {
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
WriteShadowTriangles
|
|
|
|
Writes text verts and indexes to procfile
|
|
====================
|
|
*/
|
|
static void WriteShadowTriangles( const srfTriangles_t *tri ) {
|
|
int col;
|
|
int i;
|
|
|
|
// emit this chain
|
|
procFile->WriteFloatString( "/* numVerts = */ %i /* noCaps = */ %i /* noFrontCaps = */ %i /* numIndexes = */ %i /* planeBits = */ %i\n",
|
|
tri->numVerts, tri->numShadowIndexesNoCaps, tri->numShadowIndexesNoFrontCaps, tri->numIndexes, tri->shadowCapPlaneBits );
|
|
|
|
// verts
|
|
col = 0;
|
|
for ( i = 0 ; i < tri->numVerts ; i++ ) {
|
|
Write1DMatrix( procFile, 3, &tri->shadowVertexes[i].xyz[0] );
|
|
|
|
if ( ++col == 5 ) {
|
|
col = 0;
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
if ( col != 0 ) {
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
|
|
// indexes
|
|
col = 0;
|
|
for ( i = 0 ; i < tri->numIndexes ; i++ ) {
|
|
procFile->WriteFloatString( "%i ", tri->indexes[i] );
|
|
|
|
if ( ++col == 18 ) {
|
|
col = 0;
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
if ( col != 0 ) {
|
|
procFile->WriteFloatString( "\n" );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=======================
|
|
GroupsAreSurfaceCompatible
|
|
|
|
Planes, texcoords, and groupLights can differ,
|
|
but the material and mergegroup must match
|
|
=======================
|
|
*/
|
|
static bool GroupsAreSurfaceCompatible( const optimizeGroup_t *a, const optimizeGroup_t *b ) {
|
|
if ( a->material != b->material ) {
|
|
return false;
|
|
}
|
|
if ( a->mergeGroup != b->mergeGroup ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
WriteOutputSurfaces
|
|
====================
|
|
*/
|
|
static void WriteOutputSurfaces( int entityNum, int areaNum ) {
|
|
mapTri_t *ambient, *copy;
|
|
int surfaceNum;
|
|
int numSurfaces;
|
|
idMapEntity *entity;
|
|
uArea_t *area;
|
|
optimizeGroup_t *group, *groupStep;
|
|
int i; // , j;
|
|
// int col;
|
|
srfTriangles_t *uTri;
|
|
// mapTri_t *tri;
|
|
typedef struct interactionTris_s {
|
|
struct interactionTris_s *next;
|
|
mapTri_t *triList;
|
|
mapLight_t *light;
|
|
} interactionTris_t;
|
|
|
|
interactionTris_t *interactions, *checkInter; //, *nextInter;
|
|
|
|
|
|
area = &dmapGlobals.uEntities[entityNum].areas[areaNum];
|
|
entity = dmapGlobals.uEntities[entityNum].mapEntity;
|
|
|
|
numSurfaces = CountUniqueShaders( area->groups );
|
|
|
|
|
|
if ( entityNum == 0 ) {
|
|
procFile->WriteFloatString( "model { /* name = */ \"_area%i\" /* numSurfaces = */ %i\n\n",
|
|
areaNum, numSurfaces );
|
|
} else {
|
|
const char *name;
|
|
|
|
entity->epairs.GetString( "name", "", &name );
|
|
if ( !name[0] ) {
|
|
common->Error( "Entity %i has surfaces, but no name key", entityNum );
|
|
}
|
|
procFile->WriteFloatString( "model { /* name = */ \"%s\" /* numSurfaces = */ %i\n\n",
|
|
name, numSurfaces );
|
|
}
|
|
|
|
surfaceNum = 0;
|
|
for ( group = area->groups ; group ; group = group->nextGroup ) {
|
|
if ( group->surfaceEmited ) {
|
|
continue;
|
|
}
|
|
|
|
// combine all groups compatible with this one
|
|
// usually several optimizeGroup_t can be combined into a single
|
|
// surface, even though they couldn't be merged together to save
|
|
// vertexes because they had different planes, texture coordinates, or lights.
|
|
// Different mergeGroups will stay in separate surfaces.
|
|
ambient = NULL;
|
|
|
|
// each light that illuminates any of the groups in the surface will
|
|
// get its own list of indexes out of the original surface
|
|
interactions = NULL;
|
|
|
|
for ( groupStep = group ; groupStep ; groupStep = groupStep->nextGroup ) {
|
|
if ( groupStep->surfaceEmited ) {
|
|
continue;
|
|
}
|
|
if ( !GroupsAreSurfaceCompatible( group, groupStep ) ) {
|
|
continue;
|
|
}
|
|
|
|
// copy it out to the ambient list
|
|
copy = CopyTriList( groupStep->triList );
|
|
ambient = MergeTriLists( ambient, copy );
|
|
groupStep->surfaceEmited = true;
|
|
|
|
// duplicate it into an interaction for each groupLight
|
|
for ( i = 0 ; i < groupStep->numGroupLights ; i++ ) {
|
|
for ( checkInter = interactions ; checkInter ; checkInter = checkInter->next ) {
|
|
if ( checkInter->light == groupStep->groupLights[i] ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( !checkInter ) {
|
|
// create a new interaction
|
|
checkInter = (interactionTris_t *)Mem_ClearedAlloc( sizeof( *checkInter ) );
|
|
checkInter->light = groupStep->groupLights[i];
|
|
checkInter->next = interactions;
|
|
interactions = checkInter;
|
|
}
|
|
copy = CopyTriList( groupStep->triList );
|
|
checkInter->triList = MergeTriLists( checkInter->triList, copy );
|
|
}
|
|
}
|
|
|
|
if ( !ambient ) {
|
|
continue;
|
|
}
|
|
|
|
if ( surfaceNum >= numSurfaces ) {
|
|
common->Error( "WriteOutputSurfaces: surfaceNum >= numSurfaces" );
|
|
}
|
|
|
|
procFile->WriteFloatString( "/* surface %i */ { ", surfaceNum );
|
|
surfaceNum++;
|
|
procFile->WriteFloatString( "\"%s\" ", ambient->material->GetName() );
|
|
|
|
uTri = ShareMapTriVerts( ambient );
|
|
FreeTriList( ambient );
|
|
|
|
CleanupUTriangles( uTri );
|
|
WriteUTriangles( uTri );
|
|
R_FreeStaticTriSurf( uTri );
|
|
|
|
procFile->WriteFloatString( "}\n\n" );
|
|
}
|
|
|
|
procFile->WriteFloatString( "}\n\n" );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
WriteNode_r
|
|
|
|
===============
|
|
*/
|
|
static void WriteNode_r( node_t *node ) {
|
|
int child[2];
|
|
int i;
|
|
idPlane *plane;
|
|
|
|
if ( node->planenum == PLANENUM_LEAF ) {
|
|
// we shouldn't get here unless the entire world
|
|
// was a single leaf
|
|
procFile->WriteFloatString( "/* node 0 */ ( 0 0 0 0 ) -1 -1\n" );
|
|
return;
|
|
}
|
|
|
|
for ( i = 0 ; i < 2 ; i++ ) {
|
|
if ( node->children[i]->planenum == PLANENUM_LEAF ) {
|
|
child[i] = -1 - node->children[i]->area;
|
|
} else {
|
|
child[i] = node->children[i]->nodeNumber;
|
|
}
|
|
}
|
|
|
|
plane = &dmapGlobals.mapPlanes[node->planenum];
|
|
|
|
procFile->WriteFloatString( "/* node %i */ ", node->nodeNumber );
|
|
Write1DMatrix( procFile, 4, plane->ToFloatPtr() );
|
|
procFile->WriteFloatString( "%i %i\n", child[0], child[1] );
|
|
|
|
if ( child[0] > 0 ) {
|
|
WriteNode_r( node->children[0] );
|
|
}
|
|
if ( child[1] > 0 ) {
|
|
WriteNode_r( node->children[1] );
|
|
}
|
|
}
|
|
|
|
static int NumberNodes_r( node_t *node, int nextNumber ) {
|
|
if ( node->planenum == PLANENUM_LEAF ) {
|
|
return nextNumber;
|
|
}
|
|
node->nodeNumber = nextNumber;
|
|
nextNumber++;
|
|
nextNumber = NumberNodes_r( node->children[0], nextNumber );
|
|
nextNumber = NumberNodes_r( node->children[1], nextNumber );
|
|
|
|
return nextNumber;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
WriteOutputNodes
|
|
====================
|
|
*/
|
|
static void WriteOutputNodes( node_t *node ) {
|
|
int numNodes;
|
|
|
|
// prune unneeded nodes and count
|
|
PruneNodes_r( node );
|
|
numNodes = NumberNodes_r( node, 0 );
|
|
|
|
// output
|
|
procFile->WriteFloatString( "nodes { /* numNodes = */ %i\n\n", numNodes );
|
|
procFile->WriteFloatString( "/* node format is: ( planeVector ) positiveChild negativeChild */\n" );
|
|
procFile->WriteFloatString( "/* a child number of 0 is an opaque, solid area */\n" );
|
|
procFile->WriteFloatString( "/* negative child numbers are areas: (-1-child) */\n" );
|
|
|
|
WriteNode_r( node );
|
|
|
|
procFile->WriteFloatString( "}\n\n" );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
WriteOutputPortals
|
|
====================
|
|
*/
|
|
static void WriteOutputPortals( uEntity_t *e ) {
|
|
int i, j;
|
|
interAreaPortal_t *iap;
|
|
idWinding *w;
|
|
|
|
procFile->WriteFloatString( "interAreaPortals { /* numAreas = */ %i /* numIAP = */ %i\n\n",
|
|
e->numAreas, numInterAreaPortals );
|
|
procFile->WriteFloatString( "/* interAreaPortal format is: numPoints positiveSideArea negativeSideArea ( point) ... */\n" );
|
|
for ( i = 0 ; i < numInterAreaPortals ; i++ ) {
|
|
iap = &interAreaPortals[i];
|
|
w = iap->side->winding;
|
|
procFile->WriteFloatString("/* iap %i */ %i %i %i ", i, w->GetNumPoints(), iap->area0, iap->area1 );
|
|
for ( j = 0 ; j < w->GetNumPoints() ; j++ ) {
|
|
Write1DMatrix( procFile, 3, (*w)[j].ToFloatPtr() );
|
|
}
|
|
procFile->WriteFloatString("\n" );
|
|
}
|
|
|
|
procFile->WriteFloatString( "}\n\n" );
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
WriteOutputEntity
|
|
====================
|
|
*/
|
|
static void WriteOutputEntity( int entityNum ) {
|
|
int i;
|
|
uEntity_t *e;
|
|
|
|
e = &dmapGlobals.uEntities[entityNum];
|
|
|
|
if ( entityNum != 0 ) {
|
|
// entities may have enclosed, empty areas that we don't need to write out
|
|
if ( e->numAreas > 1 ) {
|
|
e->numAreas = 1;
|
|
}
|
|
}
|
|
|
|
for ( i = 0 ; i < e->numAreas ; i++ ) {
|
|
WriteOutputSurfaces( entityNum, i );
|
|
}
|
|
|
|
// we will completely skip the portals and nodes if it is a single area
|
|
if ( entityNum == 0 && e->numAreas > 1 ) {
|
|
// output the area portals
|
|
WriteOutputPortals( e );
|
|
|
|
// output the nodes
|
|
WriteOutputNodes( e->tree->headnode );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
WriteOutputFile
|
|
====================
|
|
*/
|
|
void WriteOutputFile( void ) {
|
|
int i;
|
|
uEntity_t *entity;
|
|
idStr qpath;
|
|
|
|
// write the file
|
|
common->Printf( "----- WriteOutputFile -----\n" );
|
|
|
|
sprintf( qpath, "%s." PROC_FILE_EXT, dmapGlobals.mapFileBase );
|
|
|
|
common->Printf( "writing %s\n", qpath.c_str() );
|
|
// _D3XP used fs_cdpath
|
|
procFile = fileSystem->OpenFileWrite( qpath, "fs_devpath" );
|
|
if ( !procFile ) {
|
|
common->Error( "Error opening %s", qpath.c_str() );
|
|
}
|
|
|
|
procFile->WriteFloatString( "%s\n\n", PROC_FILE_ID );
|
|
|
|
// write the entity models and information, writing entities first
|
|
for ( i=dmapGlobals.num_entities - 1 ; i >= 0 ; i-- ) {
|
|
entity = &dmapGlobals.uEntities[i];
|
|
|
|
if ( !entity->primitives ) {
|
|
continue;
|
|
}
|
|
|
|
WriteOutputEntity( i );
|
|
}
|
|
|
|
// write the shadow volumes
|
|
for ( i = 0 ; i < dmapGlobals.mapLights.Num() ; i++ ) {
|
|
mapLight_t *light = dmapGlobals.mapLights[i];
|
|
if ( !light->shadowTris ) {
|
|
continue;
|
|
}
|
|
|
|
procFile->WriteFloatString( "shadowModel { /* name = */ \"_prelight_%s\"\n\n", light->name );
|
|
WriteShadowTriangles( light->shadowTris );
|
|
procFile->WriteFloatString( "}\n\n" );
|
|
|
|
R_FreeStaticTriSurf( light->shadowTris );
|
|
light->shadowTris = NULL;
|
|
}
|
|
|
|
fileSystem->CloseFile( procFile );
|
|
}
|