d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
527 Commits
25 Branches
6 Tags
221 MiB
Tree: 035861bf52
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '035861bf52'
${ noResults }
source-engine/utils/vbsp/map.cpp

3305 lines
92 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "vbsp.h"
#include "map_shared.h"
#include "disp_vbsp.h"
#include "tier1/strtools.h"
#include "builddisp.h"
#include "tier0/icommandline.h"
#include "KeyValues.h"
#include "materialsub.h"
#include "fgdlib/fgdlib.h"
#include "manifest.h"
#ifdef VSVMFIO
#include "VmfImport.h"
#endif // VSVMFIO
// undefine to make plane finding use linear sort
#define USE_HASHING
#define RENDER_NORMAL_EPSILON 0.00001
#define RENDER_DIST_EPSILON 0.01f
#define BRUSH_CLIP_EPSILON 0.01f // this should probably be the same
// as clip epsilon, but it is 0.1f and I
// currently don't know how that number was
// come to (cab) - this is 0.01 of an inch
// for clipping brush solids
struct LoadSide_t
{
mapbrush_t *pBrush;
side_t *pSide;
int nSideIndex;
int nBaseFlags;
int nBaseContents;
Vector planepts[3];
brush_texture_t td;
};
extern qboolean onlyents;
CUtlVector< CMapFile * > g_Maps;
CMapFile *g_MainMap = NULL;
CMapFile *g_LoadingMap = NULL;
char CMapFile::m_InstancePath[ MAX_PATH ] = "";
int CMapFile::m_InstanceCount = 0;
int CMapFile::c_areaportals = 0;
void CMapFile::Init( void )
{
entity_num = 0;
num_entities = 0;
nummapplanes = 0;
memset( mapplanes, 0, sizeof( mapplanes ) );
nummapbrushes = 0;
memset( mapbrushes, 0, sizeof( mapbrushes ) );
nummapbrushsides = 0;
memset( brushsides, 0, sizeof( brushsides ) );
memset( side_brushtextures, 0, sizeof( side_brushtextures ) );
memset( planehash, 0, sizeof( planehash ) );
m_ConnectionPairs = NULL;
m_StartMapOverlays = g_aMapOverlays.Count();
m_StartMapWaterOverlays = g_aMapWaterOverlays.Count();
c_boxbevels = 0;
c_edgebevels = 0;
c_clipbrushes = 0;
g_ClipTexinfo = -1;
}
// All the brush sides referenced by info_no_dynamic_shadow entities.
CUtlVector<int> g_NoDynamicShadowSides;
void TestExpandBrushes (void);
ChunkFileResult_t LoadDispDistancesCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispDistancesKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispInfoCallback(CChunkFile *pFile, mapdispinfo_t **ppMapDispInfo );
ChunkFileResult_t LoadDispInfoKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispNormalsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispNormalsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispOffsetsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispOffsetsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispAlphasCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispAlphasKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispTriangleTagsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispTriangleTagsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
#ifdef VSVMFIO
ChunkFileResult_t LoadDispOffsetNormalsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo);
ChunkFileResult_t LoadDispOffsetNormalsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo);
#endif // VSVMFIO
ChunkFileResult_t LoadEntityCallback(CChunkFile *pFile, int nParam);
ChunkFileResult_t LoadEntityKeyCallback(const char *szKey, const char *szValue, LoadEntity_t *pLoadEntity);
ChunkFileResult_t LoadConnectionsCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity);
ChunkFileResult_t LoadConnectionsKeyCallback(const char *szKey, const char *szValue, LoadEntity_t *pLoadEntity);
ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity);
ChunkFileResult_t LoadSolidKeyCallback(const char *szKey, const char *szValue, mapbrush_t *pLoadBrush);
ChunkFileResult_t LoadSideCallback(CChunkFile *pFile, LoadSide_t *pSideInfo);
ChunkFileResult_t LoadSideKeyCallback(const char *szKey, const char *szValue, LoadSide_t *pSideInfo);
/*
=============================================================================
PLANE FINDING
=============================================================================
*/
/*
=================
PlaneTypeForNormal
=================
*/
int PlaneTypeForNormal (Vector& normal)
{
vec_t ax, ay, az;
// NOTE: should these have an epsilon around 1.0?
if (normal[0] == 1.0 || normal[0] == -1.0)
return PLANE_X;
if (normal[1] == 1.0 || normal[1] == -1.0)
return PLANE_Y;
if (normal[2] == 1.0 || normal[2] == -1.0)
return PLANE_Z;
ax = fabs(normal[0]);
ay = fabs(normal[1]);
az = fabs(normal[2]);
if (ax >= ay && ax >= az)
return PLANE_ANYX;
if (ay >= ax && ay >= az)
return PLANE_ANYY;
return PLANE_ANYZ;
}
/*
================
PlaneEqual
================
*/
qboolean PlaneEqual (plane_t *p, Vector& normal, vec_t dist, float normalEpsilon, float distEpsilon)
{
#if 1
if (
fabs(p->normal[0] - normal[0]) < normalEpsilon
&& fabs(p->normal[1] - normal[1]) < normalEpsilon
&& fabs(p->normal[2] - normal[2]) < normalEpsilon
&& fabs(p->dist - dist) < distEpsilon )
return true;
#else
if (p->normal[0] == normal[0]
&& p->normal[1] == normal[1]
&& p->normal[2] == normal[2]
&& p->dist == dist)
return true;
#endif
return false;
}
/*
================
AddPlaneToHash
================
*/
void CMapFile::AddPlaneToHash (plane_t *p)
{
int hash;
hash = (int)fabs(p->dist) / 8;
hash &= (PLANE_HASHES-1);
p->hash_chain = planehash[hash];
planehash[hash] = p;
}
/*
================
CreateNewFloatPlane
================
*/
int CMapFile::CreateNewFloatPlane (Vector& normal, vec_t dist)
{
plane_t *p, temp;
if (VectorLength(normal) < 0.5)
g_MapError.ReportError ("FloatPlane: bad normal");
// create a new plane
if (nummapplanes+2 > MAX_MAP_PLANES)
g_MapError.ReportError ("MAX_MAP_PLANES");
p = &mapplanes[nummapplanes];
VectorCopy (normal, p->normal);
p->dist = dist;
p->type = (p+1)->type = PlaneTypeForNormal (p->normal);
VectorSubtract (vec3_origin, normal, (p+1)->normal);
(p+1)->dist = -dist;
nummapplanes += 2;
// allways put axial planes facing positive first
if (p->type < 3)
{
if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)
{
// flip order
temp = *p;
*p = *(p+1);
*(p+1) = temp;
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 1;
}
}
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 2;
}
/*
==============
SnapVector
==============
*/
bool SnapVector (Vector& normal)
{
int i;
for (i=0 ; i<3 ; i++)
{
if ( fabs(normal[i] - 1) < RENDER_NORMAL_EPSILON )
{
VectorClear (normal);
normal[i] = 1;
return true;
}
if ( fabs(normal[i] - -1) < RENDER_NORMAL_EPSILON )
{
VectorClear (normal);
normal[i] = -1;
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Snaps normal to axis-aligned if it is within an epsilon of axial.
// Rounds dist to integer if it is within an epsilon of integer.
// Input : normal - Plane normal vector (assumed to be unit length).
// dist - Plane constant.
//-----------------------------------------------------------------------------
void SnapPlane(Vector &normal, vec_t &dist)
{
SnapVector(normal);
if (fabs(dist - RoundInt(dist)) < RENDER_DIST_EPSILON)
{
dist = RoundInt(dist);
}
}
//-----------------------------------------------------------------------------
// Purpose: Snaps normal to axis-aligned if it is within an epsilon of axial.
// Recalculates dist if the normal was snapped. Rounds dist to integer
// if it is within an epsilon of integer.
// Input : normal - Plane normal vector (assumed to be unit length).
// dist - Plane constant.
// p0, p1, p2 - Three points on the plane.
//-----------------------------------------------------------------------------
void SnapPlane(Vector &normal, vec_t &dist, const Vector &p0, const Vector &p1, const Vector &p2)
{
if (SnapVector(normal))
{
//
// Calculate a new plane constant using the snapped normal. Use the
// centroid of the three plane points to minimize error. This is like
// rotating the plane around the centroid.
//
Vector p3 = (p0 + p1 + p2) / 3.0f;
dist = normal.Dot(p3);
if ( g_snapAxialPlanes )
{
dist = RoundInt(dist);
}
}
if (fabs(dist - RoundInt(dist)) < RENDER_DIST_EPSILON)
{
dist = RoundInt(dist);
}
}
/*
=============
FindFloatPlane
=============
*/
#ifndef USE_HASHING
int CMapFile::FindFloatPlane (Vector& normal, vec_t dist)
{
int i;
plane_t *p;
SnapPlane(normal, dist);
for (i=0, p=mapplanes ; i<nummapplanes ; i++, p++)
{
if (PlaneEqual (p, normal, dist, RENDER_NORMAL_EPSILON, RENDER_DIST_EPSILON))
return i;
}
return CreateNewFloatPlane (normal, dist);
}
#else
int CMapFile::FindFloatPlane (Vector& normal, vec_t dist)
{
int i;
plane_t *p;
int hash, h;
SnapPlane(normal, dist);
hash = (int)fabs(dist) / 8;
hash &= (PLANE_HASHES-1);
// search the border bins as well
for (i=-1 ; i<=1 ; i++)
{
h = (hash+i)&(PLANE_HASHES-1);
for (p = planehash[h] ; p ; p=p->hash_chain)
{
if (PlaneEqual (p, normal, dist, RENDER_NORMAL_EPSILON, RENDER_DIST_EPSILON))
return p-mapplanes;
}
}
return CreateNewFloatPlane (normal, dist);
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Builds a plane normal and distance from three points on the plane.
// If the normal is nearly axial, it will be snapped to be axial. Looks
// up the plane in the unique planes.
// Input : p0, p1, p2 - Three points on the plane.
// Output : Returns the index of the plane in the planes list.
//-----------------------------------------------------------------------------
int CMapFile::PlaneFromPoints(const Vector &p0, const Vector &p1, const Vector &p2)
{
Vector t1, t2, normal;
vec_t dist;
VectorSubtract (p0, p1, t1);
VectorSubtract (p2, p1, t2);
CrossProduct (t1, t2, normal);
VectorNormalize (normal);
dist = DotProduct (p0, normal);
SnapPlane(normal, dist, p0, p1, p2);
return FindFloatPlane (normal, dist);
}
/*
===========
BrushContents
===========
*/
int BrushContents (mapbrush_t *b)
{
int contents;
int unionContents = 0;
side_t *s;
int i;
s = &b->original_sides[0];
contents = s->contents;
unionContents = contents;
for (i=1 ; i<b->numsides ; i++, s++)
{
s = &b->original_sides[i];
unionContents |= s->contents;
#if 0
if (s->contents != contents)
{
Msg("Brush %i: mixed face contents\n", b->id);
break;
}
#endif
}
// NOTE: we're making slime translucent so that it doesn't block lighting on things floating on its surface
int transparentContents = unionContents & (CONTENTS_WINDOW|CONTENTS_GRATE|CONTENTS_WATER|CONTENTS_SLIME);
if ( transparentContents )
{
contents |= transparentContents | CONTENTS_TRANSLUCENT;
contents &= ~CONTENTS_SOLID;
}
return contents;
}
//============================================================================
bool IsAreaPortal( char const *pClassName )
{
// If the class name starts with "func_areaportal", then it's considered an area portal.
char const *pBaseName = "func_areaportal";
char const *pCur = pBaseName;
while( *pCur && *pClassName )
{
if( *pCur != *pClassName )
break;
++pCur;
++pClassName;
}
return *pCur == 0;
}
/*
=================
AddBrushBevels
Adds any additional planes necessary to allow the brush to be expanded
against axial bounding boxes
=================
*/
void CMapFile::AddBrushBevels (mapbrush_t *b)
{
int axis, dir;
int i, j, k, l, order;
side_t sidetemp;
brush_texture_t tdtemp;
side_t *s, *s2;
Vector normal;
float dist;
winding_t *w, *w2;
Vector vec, vec2;
float d;
//
// add the axial planes
//
order = 0;
for (axis=0 ; axis <3 ; axis++)
{
for (dir=-1 ; dir <= 1 ; dir+=2, order++)
{
// see if the plane is allready present
for (i=0, s=b->original_sides ; i<b->numsides ; i++,s++)
{
if (mapplanes[s->planenum].normal[axis] == dir)
break;
}
if (i == b->numsides)
{ // add a new side
if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
g_MapError.ReportError ("MAX_MAP_BRUSHSIDES");
nummapbrushsides++;
b->numsides++;
VectorClear (normal);
normal[axis] = dir;
if (dir == 1)
dist = b->maxs[axis];
else
dist = -b->mins[axis];
s->planenum = FindFloatPlane (normal, dist);
s->texinfo = b->original_sides[0].texinfo;
s->contents = b->original_sides[0].contents;
s->bevel = true;
c_boxbevels++;
}
// if the plane is not in it canonical order, swap it
if (i != order)
{
sidetemp = b->original_sides[order];
b->original_sides[order] = b->original_sides[i];
b->original_sides[i] = sidetemp;
j = b->original_sides - brushsides;
tdtemp = side_brushtextures[j+order];
side_brushtextures[j+order] = side_brushtextures[j+i];
side_brushtextures[j+i] = tdtemp;
}
}
}
//
// add the edge bevels
//
if (b->numsides == 6)
return; // pure axial
// test the non-axial plane edges
for (i=6 ; i<b->numsides ; i++)
{
s = b->original_sides + i;
w = s->winding;
if (!w)
continue;
for (j=0 ; j<w->numpoints ; j++)
{
k = (j+1)%w->numpoints;
VectorSubtract (w->p[j], w->p[k], vec);
if (VectorNormalize (vec) < 0.5)
continue;
SnapVector (vec);
for (k=0 ; k<3 ; k++)
if ( vec[k] == -1 || vec[k] == 1)
break; // axial
if (k != 3)
continue; // only test non-axial edges
// try the six possible slanted axials from this edge
for (axis=0 ; axis <3 ; axis++)
{
for (dir=-1 ; dir <= 1 ; dir+=2)
{
// construct a plane
VectorClear (vec2);
vec2[axis] = dir;
CrossProduct (vec, vec2, normal);
if (VectorNormalize (normal) < 0.5)
continue;
dist = DotProduct (w->p[j], normal);
// if all the points on all the sides are
// behind this plane, it is a proper edge bevel
for (k=0 ; k<b->numsides ; k++)
{
// if this plane has allready been used, skip it
// NOTE: Use a larger tolerance for collision planes than for rendering planes
if ( PlaneEqual(&mapplanes[b->original_sides[k].planenum], normal, dist, 0.01f, 0.01f ) )
break;
w2 = b->original_sides[k].winding;
if (!w2)
continue;
for (l=0 ; l<w2->numpoints ; l++)
{
d = DotProduct (w2->p[l], normal) - dist;
if (d > 0.1)
break; // point in front
}
if (l != w2->numpoints)
break;
}
if (k != b->numsides)
continue; // wasn't part of the outer hull
// add this plane
if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
g_MapError.ReportError ("MAX_MAP_BRUSHSIDES");
nummapbrushsides++;
s2 = &b->original_sides[b->numsides];
s2->planenum = FindFloatPlane (normal, dist);
s2->texinfo = b->original_sides[0].texinfo;
s2->contents = b->original_sides[0].contents;
s2->bevel = true;
c_edgebevels++;
b->numsides++;
}
}
}
}
}
/*
================
MakeBrushWindings
makes basewindigs for sides and mins / maxs for the brush
================
*/
qboolean CMapFile::MakeBrushWindings (mapbrush_t *ob)
{
int i, j;
winding_t *w;
side_t *side;
plane_t *plane;
ClearBounds (ob->mins, ob->maxs);
for (i=0 ; i<ob->numsides ; i++)
{
plane = &mapplanes[ob->original_sides[i].planenum];
w = BaseWindingForPlane (plane->normal, plane->dist);
for (j=0 ; j<ob->numsides && w; j++)
{
if (i == j)
continue;
if (ob->original_sides[j].bevel)
continue;
plane = &mapplanes[ob->original_sides[j].planenum^1];
// ChopWindingInPlace (&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);
// adding an epsilon here, due to precision issues creating complex
// displacement surfaces (cab)
ChopWindingInPlace( &w, plane->normal, plane->dist, BRUSH_CLIP_EPSILON );
}
side = &ob->original_sides[i];
side->winding = w;
if (w)
{
side->visible = true;
for (j=0 ; j<w->numpoints ; j++)
AddPointToBounds (w->p[j], ob->mins, ob->maxs);
}
}
for (i=0 ; i<3 ; i++)
{
if (ob->mins[i] < MIN_COORD_INTEGER || ob->maxs[i] > MAX_COORD_INTEGER)
Msg("Brush %i: bounds out of range\n", ob->id);
if (ob->mins[i] > MAX_COORD_INTEGER || ob->maxs[i] < MIN_COORD_INTEGER)
Msg("Brush %i: no visible sides on brush\n", ob->id);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Takes all of the brushes from the current entity and adds them to the
// world's brush list. Used by func_detail and func_areaportal.
// THIS ROUTINE MAY ONLY BE USED DURING ENTITY LOADING.
// Input : mapent - Entity whose brushes are to be moved to the world.
//-----------------------------------------------------------------------------
void CMapFile::MoveBrushesToWorld( entity_t *mapent )
{
int newbrushes;
int worldbrushes;
mapbrush_t *temp;
int i;
// this is pretty gross, because the brushes are expected to be
// in linear order for each entity
newbrushes = mapent->numbrushes;
worldbrushes = entities[0].numbrushes;
temp = (mapbrush_t *)malloc(newbrushes*sizeof(mapbrush_t));
memcpy (temp, mapbrushes + mapent->firstbrush, newbrushes*sizeof(mapbrush_t));
#if 0 // let them keep their original brush numbers
for (i=0 ; i<newbrushes ; i++)
temp[i].entitynum = 0;
#endif
// make space to move the brushes (overlapped copy)
memmove (mapbrushes + worldbrushes + newbrushes,
mapbrushes + worldbrushes,
sizeof(mapbrush_t) * (nummapbrushes - worldbrushes - newbrushes) );
// copy the new brushes down
memcpy (mapbrushes + worldbrushes, temp, sizeof(mapbrush_t) * newbrushes);
// fix up indexes
entities[0].numbrushes += newbrushes;
for (i=1 ; i<num_entities ; i++)
entities[i].firstbrush += newbrushes;
free (temp);
mapent->numbrushes = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Takes all of the brushes from the current entity and adds them to the
// world's brush list. Used by func_detail and func_areaportal.
// Input : mapent - Entity whose brushes are to be moved to the world.
//-----------------------------------------------------------------------------
void CMapFile::MoveBrushesToWorldGeneral( entity_t *mapent )
{
int newbrushes;
int worldbrushes;
mapbrush_t *temp;
int i;
for( i = 0; i < nummapdispinfo; i++ )
{
if ( mapdispinfo[ i ].entitynum == ( mapent - entities ) )
{
mapdispinfo[ i ].entitynum = 0;
}
}
// this is pretty gross, because the brushes are expected to be
// in linear order for each entity
newbrushes = mapent->numbrushes;
worldbrushes = entities[0].numbrushes;
temp = (mapbrush_t *)malloc(newbrushes*sizeof(mapbrush_t));
memcpy (temp, mapbrushes + mapent->firstbrush, newbrushes*sizeof(mapbrush_t));
#if 0 // let them keep their original brush numbers
for (i=0 ; i<newbrushes ; i++)
temp[i].entitynum = 0;
#endif
// make space to move the brushes (overlapped copy)
memmove (mapbrushes + worldbrushes + newbrushes,
mapbrushes + worldbrushes,
sizeof(mapbrush_t) * (mapent->firstbrush - worldbrushes) );
// wwwxxxmmyyy
// copy the new brushes down
memcpy (mapbrushes + worldbrushes, temp, sizeof(mapbrush_t) * newbrushes);
// fix up indexes
entities[0].numbrushes += newbrushes;
for (i=1 ; i<num_entities ; i++)
{
if ( entities[ i ].firstbrush < mapent->firstbrush ) // if we use <=, then we'll remap the passed in ent, which we don't want to
{
entities[ i ].firstbrush += newbrushes;
}
}
free (temp);
mapent->numbrushes = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Iterates the sides of brush and removed CONTENTS_DETAIL from each side
// Input : *brush -
//-----------------------------------------------------------------------------
void RemoveContentsDetailFromBrush( mapbrush_t *brush )
{
// Only valid on non-world brushes
Assert( brush->entitynum != 0 );
side_t *s;
int i;
s = &brush->original_sides[0];
for ( i=0 ; i<brush->numsides ; i++, s++ )
{
if ( s->contents & CONTENTS_DETAIL )
{
s->contents &= ~CONTENTS_DETAIL;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Iterates all brushes in an entity and removes CONTENTS_DETAIL from all brushes
// Input : *mapent -
//-----------------------------------------------------------------------------
void CMapFile::RemoveContentsDetailFromEntity( entity_t *mapent )
{
int i;
for ( i = 0; i < mapent->numbrushes; i++ )
{
int brushnum = mapent->firstbrush + i;
mapbrush_t *brush = &mapbrushes[ brushnum ];
RemoveContentsDetailFromBrush( brush );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFile -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispDistancesCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispDistancesKeyCallback, pMapDispInfo));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : szKey -
// szValue -
// pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispDistancesKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!strnicmp(szKey, "row", 3))
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy(szBuf, szValue);
int nCols = (1 << pMapDispInfo->power) + 1;
int nRow = atoi(&szKey[3]);
char *pszNext = strtok(szBuf, " ");
int nIndex = nRow * nCols;
while (pszNext != NULL)
{
pMapDispInfo->dispDists[nIndex] = (float)atof(pszNext);
pszNext = strtok(NULL, " ");
nIndex++;
}
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose: load in the displacement info "chunk" from the .map file into the
// vbsp map displacement info data structure
// Output : return the index of the map displacement info
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispInfoCallback(CChunkFile *pFile, mapdispinfo_t **ppMapDispInfo )
{
//
// check to see if we exceeded the maximum displacement info list size
//
if (nummapdispinfo > MAX_MAP_DISPINFO)
{
g_MapError.ReportError( "ParseDispInfoChunk: nummapdispinfo > MAX_MAP_DISPINFO" );
}
// get a pointer to the next available displacement info slot
mapdispinfo_t *pMapDispInfo = &mapdispinfo[nummapdispinfo];
nummapdispinfo++;
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler("normals", (ChunkHandler_t)LoadDispNormalsCallback, pMapDispInfo);
Handlers.AddHandler("distances", (ChunkHandler_t)LoadDispDistancesCallback, pMapDispInfo);
Handlers.AddHandler("offsets", (ChunkHandler_t)LoadDispOffsetsCallback, pMapDispInfo);
Handlers.AddHandler("alphas", (ChunkHandler_t)LoadDispAlphasCallback, pMapDispInfo);
Handlers.AddHandler("triangle_tags", (ChunkHandler_t)LoadDispTriangleTagsCallback, pMapDispInfo);
#ifdef VSVMFIO
Handlers.AddHandler("offset_normals", (ChunkHandler_t)LoadDispOffsetNormalsCallback, pMapDispInfo);
#endif // VSVMFIO
//
// Read the displacement chunk.
//
pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadDispInfoKeyCallback, pMapDispInfo);
pFile->PopHandlers();
if (eResult == ChunkFile_Ok)
{
// return a pointer to the displacement info
*ppMapDispInfo = pMapDispInfo;
}
return(eResult);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *mapent -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispInfoKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!stricmp(szKey, "power"))
{
CChunkFile::ReadKeyValueInt(szValue, pMapDispInfo->power);
}
#ifdef VSVMFIO
else if (!stricmp(szKey, "elevation"))
{
CChunkFile::ReadKeyValueFloat(szValue, pMapDispInfo->m_elevation);
}
#endif // VSVMFIO
else if (!stricmp(szKey, "uaxis"))
{
CChunkFile::ReadKeyValueVector3(szValue, pMapDispInfo->uAxis);
}
else if (!stricmp(szKey, "vaxis"))
{
CChunkFile::ReadKeyValueVector3(szValue, pMapDispInfo->vAxis);
}
else if( !stricmp( szKey, "startposition" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pMapDispInfo->startPosition );
}
else if( !stricmp( szKey, "flags" ) )
{
CChunkFile::ReadKeyValueInt( szValue, pMapDispInfo->flags );
}
#if 0 // old data
else if (!stricmp( szKey, "alpha" ) )
{
CChunkFile::ReadKeyValueVector4( szValue, pMapDispInfo->alphaValues );
}
#endif
else if (!stricmp(szKey, "mintess"))
{
CChunkFile::ReadKeyValueInt(szValue, pMapDispInfo->minTess);
}
else if (!stricmp(szKey, "smooth"))
{
CChunkFile::ReadKeyValueFloat(szValue, pMapDispInfo->smoothingAngle);
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFile -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispNormalsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispNormalsKeyCallback, pMapDispInfo));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispNormalsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!strnicmp(szKey, "row", 3))
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy(szBuf, szValue);
int nCols = (1 << pMapDispInfo->power) + 1;
int nRow = atoi(&szKey[3]);
char *pszNext0 = strtok(szBuf, " ");
char *pszNext1 = strtok(NULL, " ");
char *pszNext2 = strtok(NULL, " ");
int nIndex = nRow * nCols;
while ((pszNext0 != NULL) && (pszNext1 != NULL) && (pszNext2 != NULL))
{
pMapDispInfo->vectorDisps[nIndex][0] = (float)atof(pszNext0);
pMapDispInfo->vectorDisps[nIndex][1] = (float)atof(pszNext1);
pMapDispInfo->vectorDisps[nIndex][2] = (float)atof(pszNext2);
pszNext0 = strtok(NULL, " ");
pszNext1 = strtok(NULL, " ");
pszNext2 = strtok(NULL, " ");
nIndex++;
}
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispOffsetsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispOffsetsKeyCallback, pMapDispInfo));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispOffsetsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!strnicmp(szKey, "row", 3))
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy(szBuf, szValue);
int nCols = (1 << pMapDispInfo->power) + 1;
int nRow = atoi(&szKey[3]);
char *pszNext0 = strtok(szBuf, " ");
char *pszNext1 = strtok(NULL, " ");
char *pszNext2 = strtok(NULL, " ");
int nIndex = nRow * nCols;
while ((pszNext0 != NULL) && (pszNext1 != NULL) && (pszNext2 != NULL))
{
pMapDispInfo->vectorOffsets[nIndex][0] = (float)atof(pszNext0);
pMapDispInfo->vectorOffsets[nIndex][1] = (float)atof(pszNext1);
pMapDispInfo->vectorOffsets[nIndex][2] = (float)atof(pszNext2);
pszNext0 = strtok(NULL, " ");
pszNext1 = strtok(NULL, " ");
pszNext2 = strtok(NULL, " ");
nIndex++;
}
}
return(ChunkFile_Ok);
}
#ifdef VSVMFIO
ChunkFileResult_t LoadDispOffsetNormalsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispOffsetNormalsKeyCallback, pMapDispInfo));
}
ChunkFileResult_t LoadDispOffsetNormalsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!strnicmp(szKey, "row", 3))
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy(szBuf, szValue);
int nCols = (1 << pMapDispInfo->power) + 1;
int nRow = atoi(&szKey[3]);
char *pszNext0 = strtok(szBuf, " ");
char *pszNext1 = strtok(NULL, " ");
char *pszNext2 = strtok(NULL, " ");
int nIndex = nRow * nCols;
while ((pszNext0 != NULL) && (pszNext1 != NULL) && (pszNext2 != NULL))
{
pMapDispInfo->m_offsetNormals[nIndex][0] = (float)atof(pszNext0);
pMapDispInfo->m_offsetNormals[nIndex][1] = (float)atof(pszNext1);
pMapDispInfo->m_offsetNormals[nIndex][2] = (float)atof(pszNext2);
pszNext0 = strtok(NULL, " ");
pszNext1 = strtok(NULL, " ");
pszNext2 = strtok(NULL, " ");
nIndex++;
}
}
return(ChunkFile_Ok);
}
#endif // VSVMFIO
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispAlphasCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispAlphasKeyCallback, pMapDispInfo));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szKey -
// *szValue -
// *pDisp -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispAlphasKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if (!strnicmp(szKey, "row", 3))
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy(szBuf, szValue);
int nCols = (1 << pMapDispInfo->power) + 1;
int nRow = atoi(&szKey[3]);
char *pszNext0 = strtok(szBuf, " ");
int nIndex = nRow * nCols;
while (pszNext0 != NULL)
{
pMapDispInfo->alphaValues[nIndex] = (float)atof(pszNext0);
pszNext0 = strtok(NULL, " ");
nIndex++;
}
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispTriangleTagsCallback(CChunkFile *pFile, mapdispinfo_t *pMapDispInfo)
{
return(pFile->ReadChunk((KeyHandler_t)LoadDispTriangleTagsKeyCallback, pMapDispInfo));
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadDispTriangleTagsKeyCallback(const char *szKey, const char *szValue, mapdispinfo_t *pMapDispInfo)
{
if ( !strnicmp( szKey, "row", 3 ) )
{
char szBuf[MAX_KEYVALUE_LEN];
strcpy( szBuf, szValue );
int nCols = ( 1 << pMapDispInfo->power );
int nRow = atoi( &szKey[3] );
char *pszNext = strtok( szBuf, " " );
int nIndex = nRow * nCols;
int iTri = nIndex * 2;
while ( pszNext != NULL )
{
// Collapse the tags here!
unsigned short nTriTags = ( unsigned short )atoi( pszNext );
// Walkable
bool bWalkable = ( ( nTriTags & COREDISPTRI_TAG_WALKABLE ) != 0 );
if ( ( ( nTriTags & COREDISPTRI_TAG_FORCE_WALKABLE_BIT ) != 0 ) )
{
bWalkable = ( ( nTriTags & COREDISPTRI_TAG_FORCE_WALKABLE_VAL ) != 0 );
}
// Buildable
bool bBuildable = ( ( nTriTags & COREDISPTRI_TAG_BUILDABLE ) != 0 );
if ( ( ( nTriTags & COREDISPTRI_TAG_FORCE_BUILDABLE_BIT ) != 0 ) )
{
bBuildable = ( ( nTriTags & COREDISPTRI_TAG_FORCE_BUILDABLE_VAL ) != 0 );
}
nTriTags = 0;
if ( bWalkable )
{
nTriTags |= DISPTRI_TAG_WALKABLE;
}
if ( bBuildable )
{
nTriTags |= DISPTRI_TAG_BUILDABLE;
}
pMapDispInfo->triTags[iTri] = nTriTags;
pszNext = strtok( NULL, " " );
iTri++;
}
}
return( ChunkFile_Ok );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : brushSideID -
// Output : int
//-----------------------------------------------------------------------------
int CMapFile::SideIDToIndex( int brushSideID )
{
int i;
for ( i = 0; i < nummapbrushsides; i++ )
{
if ( brushsides[i].id == brushSideID )
{
return i;
}
}
Assert( 0 );
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *mapent -
// *key -
//-----------------------------------------------------------------------------
void ConvertSideList( entity_t *mapent, char *key )
{
char *pszSideList = ValueForKey( mapent, key );
if (pszSideList)
{
char *pszTmpList = ( char* )_alloca( strlen( pszSideList ) + 1 );
strcpy( pszTmpList, pszSideList );
bool bFirst = true;
char szNewValue[1024];
szNewValue[0] = '\0';
const char *pszScan = strtok( pszTmpList, " " );
if ( !pszScan )
return;
do
{
int nSideID;
if ( sscanf( pszScan, "%d", &nSideID ) == 1 )
{
int nIndex = g_LoadingMap->SideIDToIndex(nSideID);
if (nIndex != -1)
{
if (!bFirst)
{
strcat( szNewValue, " " );
}
else
{
bFirst = false;
}
char szIndex[15];
itoa( nIndex, szIndex, 10 );
strcat( szNewValue, szIndex );
}
}
} while ( ( pszScan = strtok( NULL, " " ) ) );
SetKeyValue( mapent, key, szNewValue );
}
}
// Add all the sides referenced by info_no_dynamic_shadows entities to g_NoDynamicShadowSides.
ChunkFileResult_t HandleNoDynamicShadowsEnt( entity_t *pMapEnt )
{
// Get the list of the sides.
char *pSideList = ValueForKey( pMapEnt, "sides" );
// Parse the side list.
char *pScan = strtok( pSideList, " " );
if( pScan )
{
do
{
int brushSideID;
if( sscanf( pScan, "%d", &brushSideID ) == 1 )
{
if ( g_NoDynamicShadowSides.Find( brushSideID ) == -1 )
g_NoDynamicShadowSides.AddToTail( brushSideID );
}
} while( ( pScan = strtok( NULL, " " ) ) );
}
// Clear out this entity.
pMapEnt->epairs = NULL;
return ( ChunkFile_Ok );
}
static ChunkFileResult_t LoadOverlayDataTransitionKeyCallback( const char *szKey, const char *szValue, mapoverlay_t *pOverlay )
{
if ( !stricmp( szKey, "material" ) )
{
// Get the material name.
const char *pMaterialName = szValue;
if( g_ReplaceMaterials )
{
pMaterialName = ReplaceMaterialName( szValue );
}
Assert( strlen( pMaterialName ) < OVERLAY_MAP_STRLEN );
if ( strlen( pMaterialName ) >= OVERLAY_MAP_STRLEN )
{
Error( "Overlay Material Name (%s) > OVERLAY_MAP_STRLEN (%d)", pMaterialName, OVERLAY_MAP_STRLEN );
return ChunkFile_Fail;
}
strcpy( pOverlay->szMaterialName, pMaterialName );
}
else if ( !stricmp( szKey, "StartU") )
{
CChunkFile::ReadKeyValueFloat( szValue, pOverlay->flU[0] );
}
else if ( !stricmp( szKey, "EndU" ) )
{
CChunkFile::ReadKeyValueFloat( szValue, pOverlay->flU[1] );
}
else if ( !stricmp( szKey, "StartV" ) )
{
CChunkFile::ReadKeyValueFloat( szValue, pOverlay->flV[0] );
}
else if ( !stricmp( szKey, "EndV" ) )
{
CChunkFile::ReadKeyValueFloat( szValue, pOverlay->flV[1] );
}
else if ( !stricmp( szKey, "BasisOrigin" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecOrigin );
}
else if ( !stricmp( szKey, "BasisU" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecBasis[0] );
}
else if ( !stricmp( szKey, "BasisV" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecBasis[1] );
}
else if ( !stricmp( szKey, "BasisNormal" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecBasis[2] );
}
else if ( !stricmp( szKey, "uv0" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecUVPoints[0] );
}
else if ( !stricmp( szKey, "uv1" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecUVPoints[1] );
}
else if ( !stricmp( szKey, "uv2" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecUVPoints[2] );
}
else if ( !stricmp( szKey, "uv3" ) )
{
CChunkFile::ReadKeyValueVector3( szValue, pOverlay->vecUVPoints[3] );
}
else if ( !stricmp( szKey, "sides" ) )
{
const char *pSideList = szValue;
char *pTmpList = ( char* )_alloca( strlen( pSideList ) + 1 );
strcpy( pTmpList, pSideList );
const char *pScan = strtok( pTmpList, " " );
if ( !pScan )
return ChunkFile_Fail;
pOverlay->aSideList.Purge();
pOverlay->aFaceList.Purge();
do
{
int nSideId;
if ( sscanf( pScan, "%d", &nSideId ) == 1 )
{
pOverlay->aSideList.AddToTail( nSideId );
}
} while ( ( pScan = strtok( NULL, " " ) ) );
}
return ChunkFile_Ok;
}
static ChunkFileResult_t LoadOverlayDataTransitionCallback( CChunkFile *pFile, int nParam )
{
int iOverlay = g_aMapWaterOverlays.AddToTail();
mapoverlay_t *pOverlay = &g_aMapWaterOverlays[iOverlay];
if ( !pOverlay )
return ChunkFile_Fail;
pOverlay->nId = ( MAX_MAP_OVERLAYS + 1 ) + g_aMapWaterOverlays.Count() - 1;
pOverlay->m_nRenderOrder = 0;
ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadOverlayDataTransitionKeyCallback, pOverlay );
return eResult;
}
static ChunkFileResult_t LoadOverlayTransitionCallback( CChunkFile *pFile, int nParam )
{
CChunkHandlerMap Handlers;
Handlers.AddHandler( "overlaydata", ( ChunkHandler_t )LoadOverlayDataTransitionCallback, 0 );
pFile->PushHandlers( &Handlers );
ChunkFileResult_t eResult = pFile->ReadChunk( NULL, NULL );
pFile->PopHandlers();
return eResult;
}
//-----------------------------------------------------------------------------
// Purpose: Iterates all brushes in a ladder entity, generates its mins and maxs.
// These are stored in the object, since the brushes are going to go away.
// Input : *mapent -
//-----------------------------------------------------------------------------
void CMapFile::AddLadderKeys( entity_t *mapent )
{
Vector mins, maxs;
ClearBounds( mins, maxs );
int i;
for ( i = 0; i < mapent->numbrushes; i++ )
{
int brushnum = mapent->firstbrush + i;
mapbrush_t *brush = &mapbrushes[ brushnum ];
AddPointToBounds( brush->mins, mins, maxs );
AddPointToBounds( brush->maxs, mins, maxs );
}
char buf[16];
Q_snprintf( buf, sizeof(buf), "%2.2f", mins.x );
SetKeyValue( mapent, "mins.x", buf );
Q_snprintf( buf, sizeof(buf), "%2.2f", mins.y );
SetKeyValue( mapent, "mins.y", buf );
Q_snprintf( buf, sizeof(buf), "%2.2f", mins.z );
SetKeyValue( mapent, "mins.z", buf );
Q_snprintf( buf, sizeof(buf), "%2.2f", maxs.x );
SetKeyValue( mapent, "maxs.x", buf );
Q_snprintf( buf, sizeof(buf), "%2.2f", maxs.y );
SetKeyValue( mapent, "maxs.y", buf );
Q_snprintf( buf, sizeof(buf), "%2.2f", maxs.z );
SetKeyValue( mapent, "maxs.z", buf );
}
ChunkFileResult_t LoadEntityCallback(CChunkFile *pFile, int nParam)
{
return g_LoadingMap->LoadEntityCallback( pFile, nParam );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFile -
// ulParam -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapFile::LoadEntityCallback(CChunkFile *pFile, int nParam)
{
if (num_entities == MAX_MAP_ENTITIES)
{
// Exits.
g_MapError.ReportError ("num_entities == MAX_MAP_ENTITIES");
}
entity_t *mapent = &entities[num_entities];
num_entities++;
memset(mapent, 0, sizeof(*mapent));
mapent->firstbrush = nummapbrushes;
mapent->numbrushes = 0;
//mapent->portalareas[0] = -1;
//mapent->portalareas[1] = -1;
LoadEntity_t LoadEntity;
LoadEntity.pEntity = mapent;
// No default flags/contents
LoadEntity.nBaseFlags = 0;
LoadEntity.nBaseContents = 0;
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler("solid", (ChunkHandler_t)::LoadSolidCallback, &LoadEntity);
Handlers.AddHandler("connections", (ChunkHandler_t)LoadConnectionsCallback, &LoadEntity);
Handlers.AddHandler( "overlaytransition", ( ChunkHandler_t )LoadOverlayTransitionCallback, 0 );
//
// Read the entity chunk.
//
pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadEntityKeyCallback, &LoadEntity);
pFile->PopHandlers();
if (eResult == ChunkFile_Ok)
{
GetVectorForKey (mapent, "origin", mapent->origin);
const char *pMinDXLevelStr = ValueForKey( mapent, "mindxlevel" );
const char *pMaxDXLevelStr = ValueForKey( mapent, "maxdxlevel" );
if( *pMinDXLevelStr != '\0' || *pMaxDXLevelStr != '\0' )
{
int min = 0;
int max = 0;
if( *pMinDXLevelStr )
{
min = atoi( pMinDXLevelStr );
}
if( *pMaxDXLevelStr )
{
max = atoi( pMaxDXLevelStr );
}
// Set min and max to default values.
if( min == 0 )
{
min = g_nDXLevel;
}
if( max == 0 )
{
max = g_nDXLevel;
}
if( ( g_nDXLevel != 0 ) && ( g_nDXLevel < min || g_nDXLevel > max ) )
{
mapent->numbrushes = 0;
mapent->epairs = NULL;
return(ChunkFile_Ok);
}
}
// offset all of the planes and texinfo
if ( mapent->origin[0] || mapent->origin[1] || mapent->origin[2] )
{
for (int i=0 ; i<mapent->numbrushes ; i++)
{
mapbrush_t *b = &mapbrushes[mapent->firstbrush + i];
for (int j=0 ; j<b->numsides ; j++)
{
side_t *s = &b->original_sides[j];
vec_t newdist = mapplanes[s->planenum].dist - DotProduct (mapplanes[s->planenum].normal, mapent->origin);
s->planenum = FindFloatPlane (mapplanes[s->planenum].normal, newdist);
if ( !onlyents )
{
s->texinfo = TexinfoForBrushTexture (&mapplanes[s->planenum], &side_brushtextures[s-brushsides], mapent->origin);
}
}
MakeBrushWindings (b);
}
}
//
// func_detail brushes are moved into the world entity. The CONTENTS_DETAIL flag was set by the loader.
//
const char *pClassName = ValueForKey( mapent, "classname" );
if ( !strcmp( "func_detail", pClassName ) )
{
MoveBrushesToWorld (mapent);
mapent->numbrushes = 0;
// clear out this entity
mapent->epairs = NULL;
return(ChunkFile_Ok);
}
// these get added to a list for processing the portal file
// but aren't necessary to emit to the BSP
if ( !strcmp( "func_viscluster", pClassName ) )
{
AddVisCluster(mapent);
return(ChunkFile_Ok);
}
//
// func_ladder brushes are moved into the world entity. We convert the func_ladder to an info_ladder
// that holds the ladder's mins and maxs, and leave the entity. This helps the bots figure out ladders.
//
if ( !strcmp( "func_ladder", pClassName ) )
{
AddLadderKeys( mapent );
MoveBrushesToWorld (mapent);
// Convert to info_ladder entity
SetKeyValue( mapent, "classname", "info_ladder" );
return(ChunkFile_Ok);
}
if( !strcmp( "env_cubemap", pClassName ) )
{
if( ( g_nDXLevel == 0 ) || ( g_nDXLevel >= 70 ) )
{
const char *pSideListStr = ValueForKey( mapent, "sides" );
int size;
size = IntForKey( mapent, "cubemapsize" );
Cubemap_InsertSample( mapent->origin, size );
Cubemap_SaveBrushSides( pSideListStr );
}
// clear out this entity
mapent->epairs = NULL;
return(ChunkFile_Ok);
}
if ( !strcmp( "test_sidelist", pClassName ) )
{
ConvertSideList(mapent, "sides");
return ChunkFile_Ok;
}
if ( !strcmp( "info_overlay", pClassName ) )
{
int iAccessorID = Overlay_GetFromEntity( mapent );
if ( iAccessorID < 0 )
{
// Clear out this entity.
mapent->epairs = NULL;
}
else
{
// Convert to info_overlay_accessor entity
SetKeyValue( mapent, "classname", "info_overlay_accessor" );
// Remember the id for accessing the overlay
char buf[16];
Q_snprintf( buf, sizeof(buf), "%i", iAccessorID );
SetKeyValue( mapent, "OverlayID", buf );
}
return ( ChunkFile_Ok );
}
if ( !strcmp( "info_overlay_transition", pClassName ) )
{
// Clear out this entity.
mapent->epairs = NULL;
return ( ChunkFile_Ok );
}
if ( Q_stricmp( pClassName, "info_no_dynamic_shadow" ) == 0 )
{
return HandleNoDynamicShadowsEnt( mapent );
}
if ( Q_stricmp( pClassName, "func_instance_parms" ) == 0 )
{
// Clear out this entity.
mapent->epairs = NULL;
return ( ChunkFile_Ok );
}
// areaportal entities move their brushes, but don't eliminate
// the entity
if( IsAreaPortal( pClassName ) )
{
char str[128];
if (mapent->numbrushes != 1)
{
Error ("Entity %i: func_areaportal can only be a single brush", num_entities-1);
}
mapbrush_t *b = &mapbrushes[nummapbrushes-1];
b->contents = CONTENTS_AREAPORTAL;
c_areaportals++;
mapent->areaportalnum = c_areaportals;
// set the portal number as "portalnumber"
sprintf (str, "%i", c_areaportals);
SetKeyValue (mapent, "portalnumber", str);
MoveBrushesToWorld (mapent);
return(ChunkFile_Ok);
}
#ifdef VSVMFIO
if ( !Q_stricmp( pClassName, "light" ) )
{
CVmfImport::GetVmfImporter()->ImportLightCallback(
ValueForKey( mapent, "hammerid" ),
ValueForKey( mapent, "origin" ),
ValueForKey( mapent, "_light" ),
ValueForKey( mapent, "_lightHDR" ),
ValueForKey( mapent, "_lightscaleHDR" ),
ValueForKey( mapent, "_quadratic_attn" ) );
}
if ( !Q_stricmp( pClassName, "light_spot" ) )
{
CVmfImport::GetVmfImporter()->ImportLightSpotCallback(
ValueForKey( mapent, "hammerid" ),
ValueForKey( mapent, "origin" ),
ValueForKey( mapent, "angles" ),
ValueForKey( mapent, "pitch" ),
ValueForKey( mapent, "_light" ),
ValueForKey( mapent, "_lightHDR" ),
ValueForKey( mapent, "_lightscaleHDR" ),
ValueForKey( mapent, "_quadratic_attn" ),
ValueForKey( mapent, "_inner_cone" ),
ValueForKey( mapent, "_cone" ),
ValueForKey( mapent, "_exponent" ) );
}
if ( !Q_stricmp( pClassName, "light_dynamic" ) )
{
CVmfImport::GetVmfImporter()->ImportLightDynamicCallback(
ValueForKey( mapent, "hammerid" ),
ValueForKey( mapent, "origin" ),
ValueForKey( mapent, "angles" ),
ValueForKey( mapent, "pitch" ),
ValueForKey( mapent, "_light" ),
ValueForKey( mapent, "_quadratic_attn" ),
ValueForKey( mapent, "_inner_cone" ),
ValueForKey( mapent, "_cone" ),
ValueForKey( mapent, "brightness" ),
ValueForKey( mapent, "distance" ),
ValueForKey( mapent, "spotlight_radius" ) );
}
if ( !Q_stricmp( pClassName, "light_environment" ) )
{
CVmfImport::GetVmfImporter()->ImportLightEnvironmentCallback(
ValueForKey( mapent, "hammerid" ),
ValueForKey( mapent, "origin" ),
ValueForKey( mapent, "angles" ),
ValueForKey( mapent, "pitch" ),
ValueForKey( mapent, "_light" ),
ValueForKey( mapent, "_lightHDR" ),
ValueForKey( mapent, "_lightscaleHDR" ),
ValueForKey( mapent, "_ambient" ),
ValueForKey( mapent, "_ambientHDR" ),
ValueForKey( mapent, "_AmbientScaleHDR" ),
ValueForKey( mapent, "SunSpreadAngle" ) );
}
const char *pModel = ValueForKey( mapent, "model" );
if ( pModel && Q_strlen( pModel ) )
{
CVmfImport::GetVmfImporter()->ImportModelCallback(
pModel,
ValueForKey( mapent, "hammerid" ),
ValueForKey( mapent, "angles" ),
ValueForKey( mapent, "origin" ),
MDagPath() );
}
#endif // VSVMFIO
// If it's not in the world at this point, unmark CONTENTS_DETAIL from all sides...
if ( mapent != &entities[ 0 ] )
{
RemoveContentsDetailFromEntity( mapent );
}
return(ChunkFile_Ok);
}
return(eResult);
}
entity_t* EntityByName( char const *pTestName )
{
if( !pTestName )
return 0;
for( int i=0; i < g_MainMap->num_entities; i++ )
{
entity_t *e = &g_MainMap->entities[i];
const char *pName = ValueForKey( e, "targetname" );
if( stricmp( pName, pTestName ) == 0 )
return e;
}
return 0;
}
void CMapFile::ForceFuncAreaPortalWindowContents()
{
// Now go through all areaportal entities and force CONTENTS_WINDOW
// on the brushes of the bmodels they point at.
char *targets[] = {"target", "BackgroundBModel"};
int nTargets = sizeof(targets) / sizeof(targets[0]);
for( int i=0; i < num_entities; i++ )
{
entity_t *e = &entities[i];
const char *pClassName = ValueForKey( e, "classname" );
// Don't do this on "normal" func_areaportal entities. Those are tied to doors
// and should be opaque when closed. But areaportal windows (and any other
// distance-based areaportals) should be windows because they are normally open/transparent
if( !IsAreaPortal( pClassName ) || !Q_stricmp( pClassName, "func_areaportal" ) )
continue;
// const char *pTestEntName = ValueForKey( e, "targetname" );
for( int iTarget=0; iTarget < nTargets; iTarget++ )
{
char const *pEntName = ValueForKey( e, targets[iTarget] );
if( !pEntName[0] )
continue;
entity_t *pBrushEnt = EntityByName( pEntName );
if( !pBrushEnt )
continue;
for( int iBrush=0; iBrush < pBrushEnt->numbrushes; iBrush++ )
{
mapbrushes[pBrushEnt->firstbrush + iBrush].contents &= ~CONTENTS_SOLID;
mapbrushes[pBrushEnt->firstbrush + iBrush].contents |= CONTENTS_TRANSLUCENT | CONTENTS_WINDOW;
}
}
}
}
// ============ Instancing ============
// #define MERGE_INSTANCE_DEBUG_INFO 1
#define INSTANCE_VARIABLE_KEY "replace"
static GameData GD;
//-----------------------------------------------------------------------------
// Purpose: this function will read in a standard key / value file
// Input : pFilename - the absolute name of the file to read
// Output : returns the KeyValues of the file, NULL if the file could not be read.
//-----------------------------------------------------------------------------
static KeyValues *ReadKeyValuesFile( const char *pFilename )
{
// Read in the gameinfo.txt file and null-terminate it.
FILE *fp = fopen( pFilename, "rb" );
if ( !fp )
return NULL;
CUtlVector<char> buf;
fseek( fp, 0, SEEK_END );
buf.SetSize( ftell( fp ) + 1 );
fseek( fp, 0, SEEK_SET );
fread( buf.Base(), 1, buf.Count()-1, fp );
fclose( fp );
buf[buf.Count()-1] = 0;
KeyValues *kv = new KeyValues( "" );
if ( !kv->LoadFromBuffer( pFilename, buf.Base() ) )
{
kv->deleteThis();
return NULL;
}
return kv;
}
//-----------------------------------------------------------------------------
// Purpose: this function will set a secondary lookup path for instances.
// Input : pszInstancePath - the secondary lookup path
//-----------------------------------------------------------------------------
void CMapFile::SetInstancePath( const char *pszInstancePath )
{
strcpy( m_InstancePath, pszInstancePath );
V_strlower( m_InstancePath );
V_FixSlashes( m_InstancePath );
}
//-----------------------------------------------------------------------------
// Purpose: This function will attempt to find a full path given the base and relative names.
// Input : pszBaseFileName - the base file that referenced this instance
// pszInstanceFileName - the relative file name of this instance
// Output : Returns true if it was able to locate the file
// pszOutFileName - the full path to the file name if located
//-----------------------------------------------------------------------------
bool CMapFile::DeterminePath( const char *pszBaseFileName, const char *pszInstanceFileName, char *pszOutFileName )
{
char szInstanceFileNameFixed[ MAX_PATH ];
const char *pszMapPath = "\\maps\\";
strcpy( szInstanceFileNameFixed, pszInstanceFileName );
V_SetExtension( szInstanceFileNameFixed, ".vmf", sizeof( szInstanceFileNameFixed ) );
V_FixSlashes( szInstanceFileNameFixed );
// first, try to find a relative location based upon the Base file name
strcpy( pszOutFileName, pszBaseFileName );
V_StripFilename( pszOutFileName );
strcat( pszOutFileName, "\\" );
strcat( pszOutFileName, szInstanceFileNameFixed );
if ( g_pFullFileSystem->FileExists( pszOutFileName ) )
{
return true;
}
// second, try to find the master 'maps' directory and make it relative from that
strcpy( pszOutFileName, pszBaseFileName );
V_StripFilename( pszOutFileName );
V_RemoveDotSlashes( pszOutFileName );
V_FixDoubleSlashes( pszOutFileName );
V_strlower( pszOutFileName );
strcat( pszOutFileName, "\\" );
char *pos = strstr( pszOutFileName, pszMapPath );
if ( pos )
{
pos += strlen( pszMapPath );
*pos = 0;
strcat( pszOutFileName, szInstanceFileNameFixed );
if ( g_pFullFileSystem->FileExists( pszOutFileName ) )
{
return true;
}
}
if ( m_InstancePath[ 0 ] != 0 )
{
sprintf( szInstanceFileNameFixed, "%s%s", m_InstancePath, pszInstanceFileName );
if ( g_pFullFileSystem->FileExists( szInstanceFileNameFixed, "GAME" ) )
{
char FullPath[ MAX_PATH ];
g_pFullFileSystem->RelativePathToFullPath( szInstanceFileNameFixed, "GAME", FullPath, sizeof( FullPath ) );
strcpy( pszOutFileName, FullPath );
return true;
}
}
pszOutFileName[ 0 ] = 0;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: this function will check the main map for any func_instances. It will
// also attempt to load in the gamedata file for instancing remapping help.
// Input : none
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::CheckForInstances( const char *pszFileName )
{
if ( this != g_MainMap )
{ // all sub-instances will be appended to the main map master list as they are read in
// so the main loop below will naturally get to the appended ones.
return;
}
char GameInfoPath[ MAX_PATH ];
g_pFullFileSystem->RelativePathToFullPath( "gameinfo.txt", "MOD", GameInfoPath, sizeof( GameInfoPath ) );
KeyValues *GameInfoKV = ReadKeyValuesFile( GameInfoPath );
if ( !GameInfoKV )
{
Msg( "Could not locate gameinfo.txt for Instance Remapping at %s\n", GameInfoPath );
return;
}
const char *InstancePath = GameInfoKV->GetString( "InstancePath", NULL );
if ( InstancePath )
{
CMapFile::SetInstancePath( InstancePath );
}
const char *GameDataFile = GameInfoKV->GetString( "GameData", NULL );
if ( !GameDataFile )
{
Msg( "Could not locate 'GameData' key in %s\n", GameInfoPath );
return;
}
char FDGPath[ MAX_PATH ];
if ( !g_pFullFileSystem->RelativePathToFullPath( GameDataFile, "EXECUTABLE_PATH", FDGPath, sizeof( FDGPath ) ) )
{
if ( !g_pFullFileSystem->RelativePathToFullPath( GameDataFile, NULL, FDGPath, sizeof( FDGPath ) ) )
{
Msg( "Could not locate GameData file %s\n", GameDataFile );
}
}
GD.Load( FDGPath );
// this list will grow as instances are merged onto it. sub-instances are merged and
// automatically done in this processing.
for ( int i = 0; i < num_entities; i++ )
{
char *pEntity = ValueForKey( &entities[ i ], "classname" );
if ( !strcmp( pEntity, "func_instance" ) )
{
char *pInstanceFile = ValueForKey( &entities[ i ], "file" );
if ( pInstanceFile[ 0 ] )
{
char InstancePath[ MAX_PATH ];
bool bLoaded = false;
if ( DeterminePath( pszFileName, pInstanceFile, InstancePath ) )
{
if ( LoadMapFile( InstancePath ) )
{
MergeInstance( &entities[ i ], g_LoadingMap );
delete g_LoadingMap;
bLoaded = true;
}
}
if ( bLoaded == false )
{
Color red( 255, 0, 0, 255 );
ColorSpewMessage( SPEW_ERROR, &red, "Could not open instance file %s\n", pInstanceFile );
}
}
entities[ i ].numbrushes = 0;
entities[ i ].epairs = NULL;
}
}
g_LoadingMap = this;
}
//-----------------------------------------------------------------------------
// Purpose: this function will do all of the necessary work to merge the instance
// into the main map.
// Input : pInstanceEntity - the entity of the func_instance
// Instance - the map file of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergeInstance( entity_t *pInstanceEntity, CMapFile *Instance )
{
matrix3x4_t mat;
QAngle angles;
Vector OriginOffset = pInstanceEntity->origin;
m_InstanceCount++;
GetAnglesForKey( pInstanceEntity, "angles", angles );
AngleMatrix( angles, OriginOffset, mat );
#ifdef MERGE_INSTANCE_DEBUG_INFO
Msg( "Instance Remapping: O:( %g, %g, %g ) A:( %g, %g, %g )\n", OriginOffset.x, OriginOffset.y, OriginOffset.z, angles.x, angles.y, angles.z );
#endif // #ifdef MERGE_INSTANCE_DEBUG_INFO
MergePlanes( pInstanceEntity, Instance, OriginOffset, angles, mat );
MergeBrushes( pInstanceEntity, Instance, OriginOffset, angles, mat );
MergeBrushSides( pInstanceEntity, Instance, OriginOffset, angles, mat );
MergeEntities( pInstanceEntity, Instance, OriginOffset, angles, mat );
MergeOverlays( pInstanceEntity, Instance, OriginOffset, angles, mat );
}
//-----------------------------------------------------------------------------
// Purpose: this function will merge in the map planes from the instance into
// the main map.
// Input : pInstanceEntity - the entity of the func_instance
// Instance - the map file of the instance
// InstanceOrigin - the translation of the instance
// InstanceAngle - the rotation of the instance
// InstanceMatrix - the translation / rotation matrix of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergePlanes( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix )
{
// Each pair of planes needs to be added to the main map
for ( int i = 0; i < Instance->nummapplanes; i += 2 )
{
FindFloatPlane( Instance->mapplanes[i].normal, Instance->mapplanes[i].dist );
}
}
//-----------------------------------------------------------------------------
// Purpose: this function will merge in the map brushes from the instance into
// the main map.
// Input : pInstanceEntity - the entity of the func_instance
// Instance - the map file of the instance
// InstanceOrigin - the translation of the instance
// InstanceAngle - the rotation of the instance
// InstanceMatrix - the translation / rotation matrix of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergeBrushes( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix )
{
int max_brush_id = 0;
for( int i = 0; i < nummapbrushes; i++ )
{
if ( mapbrushes[ i ].id > max_brush_id )
{
max_brush_id = mapbrushes[ i ].id;
}
}
for( int i = 0; i < Instance->nummapbrushes; i++ )
{
mapbrushes[ nummapbrushes + i ] = Instance->mapbrushes[ i ];
mapbrush_t *brush = &mapbrushes[ nummapbrushes + i ];
brush->entitynum += num_entities;
brush->brushnum += nummapbrushes;
if ( i < Instance->entities[ 0 ].numbrushes || ( brush->contents & CONTENTS_LADDER ) != 0 )
{ // world spawn brushes as well as ladders we physically move
Vector minsIn = brush->mins;
Vector maxsIn = brush->maxs;
TransformAABB( InstanceMatrix, minsIn, maxsIn, brush->mins, brush->maxs );
}
else
{
}
brush->id += max_brush_id;
int index = brush->original_sides - Instance->brushsides;
brush->original_sides = &brushsides[ nummapbrushsides + index ];
}
nummapbrushes += Instance->nummapbrushes;
}
//-----------------------------------------------------------------------------
// Purpose: this function will merge in the map sides from the instance into
// the main map.
// Input : pInstanceEntity - the entity of the func_instance
// Instance - the map file of the instance
// InstanceOrigin - the translation of the instance
// InstanceAngle - the rotation of the instance
// InstanceMatrix - the translation / rotation matrix of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergeBrushSides( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix )
{
int max_side_id = 0;
for( int i = 0; i < nummapbrushsides; i++ )
{
if ( brushsides[ i ].id > max_side_id )
{
max_side_id = brushsides[ i ].id;
}
}
for( int i = 0; i < Instance->nummapbrushsides; i++ )
{
brushsides[ nummapbrushsides + i ] = Instance->brushsides[ i ];
side_t *side = &brushsides[ nummapbrushsides + i ];
// The planes got merged & remapped. So you need to search for the output plane index on each side
// NOTE: You could optimize this by saving off an index map in MergePlanes
side->planenum = FindFloatPlane( Instance->mapplanes[side->planenum].normal, Instance->mapplanes[side->planenum].dist );
side->id += max_side_id;
// this could be pre-processed into a list for quicker checking
bool bNeedsTranslation = ( side->pMapDisp && side->pMapDisp->entitynum == 0 );
if ( !bNeedsTranslation )
{ // check for sides that are part of the world spawn - those need translating
for( int j = 0; j < Instance->entities[ 0 ].numbrushes; j++ )
{
int loc = Instance->mapbrushes[ j ].original_sides - Instance->brushsides;
if ( i >= loc && i < ( loc + Instance->mapbrushes[ j ].numsides ) )
{
bNeedsTranslation = true;
break;
}
}
}
if ( !bNeedsTranslation )
{ // sides for ladders are outside of the world spawn, but also need translating
for( int j = Instance->entities[ 0 ].numbrushes; j < Instance->nummapbrushes; j++ )
{
int loc = Instance->mapbrushes[ j ].original_sides - Instance->brushsides;
if ( i >= loc && i < ( loc + Instance->mapbrushes[ j ].numsides ) && ( Instance->mapbrushes[ j ].contents & CONTENTS_LADDER ) != 0 )
{
bNeedsTranslation = true;
break;
}
}
}
if ( bNeedsTranslation )
{ // we only want to do the adjustment on world spawn brushes, not entity brushes
if ( side->winding )
{
for( int point = 0; point < side->winding->numpoints; point++ )
{
Vector inPoint = side->winding->p[ point ];
VectorTransform( inPoint, InstanceMatrix, side->winding->p[ point ] );
}
}
int planenum = side->planenum;
cplane_t inPlane, outPlane;
inPlane.normal = mapplanes[ planenum ].normal;
inPlane.dist = mapplanes[ planenum ].dist;
MatrixTransformPlane( InstanceMatrix, inPlane, outPlane );
planenum = FindFloatPlane( outPlane.normal, outPlane.dist );
side->planenum = planenum;
brush_texture_t bt = Instance->side_brushtextures[ i ];
VectorRotate( Instance->side_brushtextures[ i ].UAxis, InstanceMatrix, bt.UAxis );
VectorRotate( Instance->side_brushtextures[ i ].VAxis, InstanceMatrix, bt.VAxis );
bt.shift[ 0 ] -= InstanceOrigin.Dot( bt.UAxis ) / bt.textureWorldUnitsPerTexel[ 0 ];
bt.shift[ 1 ] -= InstanceOrigin.Dot( bt.VAxis ) / bt.textureWorldUnitsPerTexel[ 1 ];
if ( !onlyents )
{
side->texinfo = TexinfoForBrushTexture ( &mapplanes[ side->planenum ], &bt, vec3_origin );
}
}
if ( side->pMapDisp )
{
mapdispinfo_t *disp = side->pMapDisp;
disp->brushSideID = side->id;
Vector inPoint = disp->startPosition;
VectorTransform( inPoint, InstanceMatrix, disp->startPosition );
disp->face.originalface = side;
disp->face.texinfo = side->texinfo;
disp->face.planenum = side->planenum;
disp->entitynum += num_entities;
for( int point = 0; point < disp->face.w->numpoints; point++ )
{
Vector inPoint = disp->face.w->p[ point ];
VectorTransform( inPoint, InstanceMatrix, disp->face.w->p[ point ] );
}
}
}
nummapbrushsides += Instance->nummapbrushsides;
}
//-----------------------------------------------------------------------------
// Purpose: this function will look for replace parameters in the function instance
// to see if there is anything in the epair that should be replaced.
// Input : pPair - the epair with the value
// pInstanceEntity - the func_instance that may ahve replace keywords
// Output : pPair - the value field may be updated
//-----------------------------------------------------------------------------
void CMapFile::ReplaceInstancePair( epair_t *pPair, entity_t *pInstanceEntity )
{
char Value[ MAX_KEYVALUE_LEN ], NewValue[ MAX_KEYVALUE_LEN ];
bool Overwritten = false;
strcpy( NewValue, pPair->value );
for ( epair_t *epInstance = pInstanceEntity->epairs; epInstance != NULL; epInstance = epInstance->next )
{
if ( strnicmp( epInstance->key, INSTANCE_VARIABLE_KEY, strlen( INSTANCE_VARIABLE_KEY ) ) == 0 )
{
char InstanceVariable[ MAX_KEYVALUE_LEN ];
strcpy( InstanceVariable, epInstance->value );
char *ValuePos = strchr( InstanceVariable, ' ' );
if ( !ValuePos )
{
continue;
}
*ValuePos = 0;
ValuePos++;
strcpy( Value, NewValue );
if ( !V_StrSubst( Value, InstanceVariable, ValuePos, NewValue, sizeof( NewValue ), false ) )
{
Overwritten = true;
break;
}
}
}
if ( !Overwritten && strcmp( pPair->value, NewValue ) != 0 )
{
free( pPair->value );
pPair->value = copystring( NewValue );
}
}
//-----------------------------------------------------------------------------
// Purpose: this function will merge in the entities from the instance into
// the main map.
// Input : pInstanceEntity - the entity of the func_instance
// Instance - the map file of the instance
// InstanceOrigin - the translation of the instance
// InstanceAngle - the rotation of the instance
// InstanceMatrix - the translation / rotation matrix of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergeEntities( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix )
{
int max_entity_id = 0;
char temp[ 2048 ];
char NameFixup[ 128 ];
entity_t *WorldspawnEnt = NULL;
GameData::TNameFixup FixupStyle;
char *pTargetName = ValueForKey( pInstanceEntity, "targetname" );
char *pName = ValueForKey( pInstanceEntity, "name" );
if ( pTargetName[ 0 ] )
{
sprintf( NameFixup, "%s", pTargetName );
}
else if ( pName[ 0 ] )
{
sprintf( NameFixup, "%s", pName );
}
else
{
sprintf( NameFixup, "InstanceAuto%d", m_InstanceCount );
}
for( int i = 0; i < num_entities; i++ )
{
char *pID = ValueForKey( &entities[ i ], "hammerid" );
if ( pID[ 0 ] )
{
int value = atoi( pID );
if ( value > max_entity_id )
{
max_entity_id = value;
}
}
}
FixupStyle = ( GameData::TNameFixup )( IntForKey( pInstanceEntity, "fixup_style" ) );
for( int i = 0; i < Instance->num_entities; i++ )
{
entities[ num_entities + i ] = Instance->entities[ i ];
entity_t *entity = &entities[ num_entities + i ];
entity->firstbrush += ( nummapbrushes - Instance->nummapbrushes );
char *pID = ValueForKey( entity, "hammerid" );
if ( pID[ 0 ] )
{
int value = atoi( pID );
value += max_entity_id;
sprintf( temp, "%d", value );
SetKeyValue( entity, "hammerid", temp );
}
char *pEntity = ValueForKey( entity, "classname" );
if ( strcmpi( pEntity, "worldspawn" ) == 0 )
{
WorldspawnEnt = entity;
}
else
{
Vector inOrigin = entity->origin;
VectorTransform( inOrigin, InstanceMatrix, entity->origin );
// search for variables coming from the func_instance to replace inside of the instance
// this is done before entity fixup, so fixup may occur on the replaced value. Not sure if this is a desired order of operation yet.
for ( epair_t *ep = entity->epairs; ep != NULL; ep = ep->next )
{
ReplaceInstancePair( ep, pInstanceEntity );
}
#ifdef MERGE_INSTANCE_DEBUG_INFO
Msg( "Remapping class %s\n", pEntity );
#endif // #ifdef MERGE_INSTANCE_DEBUG_INFO
GDclass *EntClass = GD.BeginInstanceRemap( pEntity, NameFixup, InstanceOrigin, InstanceAngle );
if ( EntClass )
{
for( int i = 0; i < EntClass->GetVariableCount(); i++ )
{
GDinputvariable *EntVar = EntClass->GetVariableAt( i );
char *pValue = ValueForKey( entity, ( char * )EntVar->GetName() );
if ( GD.RemapKeyValue( EntVar->GetName(), pValue, temp, FixupStyle ) )
{
#ifdef MERGE_INSTANCE_DEBUG_INFO
Msg( " %d. Remapped %s: from %s to %s\n", i, EntVar->GetName(), pValue, temp );
#endif // #ifdef MERGE_INSTANCE_DEBUG_INFO
SetKeyValue( entity, EntVar->GetName(), temp );
}
else
{
#ifdef MERGE_INSTANCE_DEBUG_INFO
Msg( " %d. Ignored %s: %s\n", i, EntVar->GetName(), pValue );
#endif // #ifdef MERGE_INSTANCE_DEBUG_INFO
}
}
}
if ( strcmpi( pEntity, "func_simpleladder" ) == 0 )
{ // hate having to do this, but the key values are so screwed up
AddLadderKeys( entity );
/* Vector vInNormal, vOutNormal;
vInNormal.x = FloatForKey( entity, "normal.x" );
vInNormal.y = FloatForKey( entity, "normal.y" );
vInNormal.z = FloatForKey( entity, "normal.z" );
VectorRotate( vInNormal, InstanceMatrix, vOutNormal );
Q_snprintf( temp, sizeof( temp ), "%f", vOutNormal.x );
SetKeyValue( entity, "normal.x", temp );
Q_snprintf( temp, sizeof( temp ), "%f", vOutNormal.y );
SetKeyValue( entity, "normal.y", temp );
Q_snprintf( temp, sizeof( temp ), "%f", vOutNormal.z );
SetKeyValue( entity, "normal.z", temp );*/
}
}
#ifdef MERGE_INSTANCE_DEBUG_INFO
Msg( "Instance Entity %d remapped to %d\n", i, num_entities + i );
Msg( " FirstBrush: from %d to %d\n", Instance->entities[ i ].firstbrush, entity->firstbrush );
Msg( " KV Pairs:\n" );
for ( epair_t *ep = entity->epairs; ep->next != NULL; ep = ep->next )
{
Msg( " %s %s\n", ep->key, ep->value );
}
#endif // #ifdef MERGE_INSTANCE_DEBUG_INFO
}
// search for variables coming from the func_instance to replace inside of the instance
// this is done before connection fix up, so fix up may occur on the replaced value. Not sure if this is a desired order of operation yet.
for( CConnectionPairs *Connection = Instance->m_ConnectionPairs; Connection; Connection = Connection->m_Next )
{
ReplaceInstancePair( Connection->m_Pair, pInstanceEntity );
}
for( CConnectionPairs *Connection = Instance->m_ConnectionPairs; Connection; Connection = Connection->m_Next )
{
char *newValue, *oldValue;
char origValue[ 4096 ];
int extraLen = 0;
oldValue = Connection->m_Pair->value;
strcpy( origValue, oldValue );
char *pos = strchr( origValue, ',' );
if ( pos )
{ // null terminate the first field
*pos = NULL;
extraLen = strlen( pos + 1) + 1; // for the comma we just null'd
}
if ( GD.RemapNameField( origValue, temp, FixupStyle ) )
{
newValue = new char [ strlen( temp ) + extraLen + 1 ];
strcpy( newValue, temp );
if ( pos )
{
strcat( newValue, "," );
strcat( newValue, pos + 1 );
}
Connection->m_Pair->value = newValue;
delete oldValue;
}
}
num_entities += Instance->num_entities;
MoveBrushesToWorldGeneral( WorldspawnEnt );
WorldspawnEnt->numbrushes = 0;
WorldspawnEnt->epairs = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: this function will translate overlays from the instance into
// the main map.
// Input : InstanceEntityNum - the entity number of the func_instance
// Instance - the map file of the instance
// InstanceOrigin - the translation of the instance
// InstanceAngle - the rotation of the instance
// InstanceMatrix - the translation / rotation matrix of the instance
// Output : none
//-----------------------------------------------------------------------------
void CMapFile::MergeOverlays( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix )
{
for( int i = Instance->m_StartMapOverlays; i < g_aMapOverlays.Count(); i++ )
{
Overlay_Translate( &g_aMapOverlays[ i ], InstanceOrigin, InstanceAngle, InstanceMatrix );
}
for( int i = Instance->m_StartMapWaterOverlays; i < g_aMapWaterOverlays.Count(); i++ )
{
Overlay_Translate( &g_aMapWaterOverlays[ i ], InstanceOrigin, InstanceAngle, InstanceMatrix );
}
}
//-----------------------------------------------------------------------------
// Purpose: Loads a VMF or MAP file. If the file has a .MAP extension, the MAP
// loader is used, otherwise the file is assumed to be in VMF format.
// Input : pszFileName - Full path of the map file to load.
//-----------------------------------------------------------------------------
bool LoadMapFile( const char *pszFileName )
{
bool bLoadingManifest = false;
CManifest *pMainManifest = NULL;
ChunkFileResult_t eResult;
//
// Dummy this up for the texture handling. This can be removed when old .MAP file
// support is removed.
//
g_nMapFileVersion = 400;
const char *pszExtension =V_GetFileExtension( pszFileName );
if ( pszExtension && strcmpi( pszExtension, "vmm" ) == 0 )
{
pMainManifest = new CManifest();
if ( pMainManifest->LoadVMFManifest( pszFileName ) )
{
eResult = ChunkFile_Ok;
pszFileName = pMainManifest->GetInstancePath();
}
else
{
eResult = ChunkFile_Fail;
}
bLoadingManifest = true;
}
else
{
//
// Open the file.
//
CChunkFile File;
eResult = File.Open(pszFileName, ChunkFile_Read);
//
// Read the file.
//
if (eResult == ChunkFile_Ok)
{
int index = g_Maps.AddToTail( new CMapFile() );
g_LoadingMap = g_Maps[ index ];
if ( g_MainMap == NULL )
{
g_MainMap = g_LoadingMap;
}
if ( g_MainMap == g_LoadingMap || verbose )
{
Msg( "Loading %s\n", pszFileName );
}
// reset the displacement info count
// nummapdispinfo = 0;
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler("world", (ChunkHandler_t)LoadEntityCallback, 0);
Handlers.AddHandler("entity", (ChunkHandler_t)LoadEntityCallback, 0);
File.PushHandlers(&Handlers);
//
// Read the sub-chunks. We ignore keys in the root of the file.
//
while (eResult == ChunkFile_Ok)
{
eResult = File.ReadChunk();
}
File.PopHandlers();
}
else
{
Error("Error opening %s: %s.\n", pszFileName, File.GetErrorText(eResult));
}
}
if ((eResult == ChunkFile_Ok) || (eResult == ChunkFile_EOF))
{
// Update the overlay/side list(s).
Overlay_UpdateSideLists( g_LoadingMap->m_StartMapOverlays );
OverlayTransition_UpdateSideLists( g_LoadingMap->m_StartMapWaterOverlays );
g_LoadingMap->CheckForInstances( pszFileName );
if ( pMainManifest )
{
pMainManifest->CordonWorld();
}
ClearBounds (g_LoadingMap->map_mins, g_LoadingMap->map_maxs);
for (int i=0 ; i<g_MainMap->entities[0].numbrushes ; i++)
{
// HLTOOLS: Raise map limits
if (g_LoadingMap->mapbrushes[i].mins[0] > MAX_COORD_INTEGER)
{
continue; // no valid points
}
AddPointToBounds (g_LoadingMap->mapbrushes[i].mins, g_LoadingMap->map_mins, g_LoadingMap->map_maxs);
AddPointToBounds (g_LoadingMap->mapbrushes[i].maxs, g_LoadingMap->map_mins, g_LoadingMap->map_maxs);
}
qprintf ("%5i brushes\n", g_LoadingMap->nummapbrushes);
qprintf ("%5i clipbrushes\n", g_LoadingMap->c_clipbrushes);
qprintf ("%5i total sides\n", g_LoadingMap->nummapbrushsides);
qprintf ("%5i boxbevels\n", g_LoadingMap->c_boxbevels);
qprintf ("%5i edgebevels\n", g_LoadingMap->c_edgebevels);
qprintf ("%5i entities\n", g_LoadingMap->num_entities);
qprintf ("%5i planes\n", g_LoadingMap->nummapplanes);
qprintf ("%5i areaportals\n", g_LoadingMap->c_areaportals);
qprintf ("size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", g_LoadingMap->map_mins[0],g_LoadingMap->map_mins[1],g_LoadingMap->map_mins[2],
g_LoadingMap->map_maxs[0],g_LoadingMap->map_maxs[1],g_LoadingMap->map_maxs[2]);
//TestExpandBrushes();
// Clear the error reporting
g_MapError.ClearState();
}
if ( g_MainMap == g_LoadingMap )
{
num_entities = g_MainMap->num_entities;
memcpy( entities, g_MainMap->entities, sizeof( g_MainMap->entities ) );
}
g_LoadingMap->ForceFuncAreaPortalWindowContents();
return ( ( eResult == ChunkFile_Ok ) || ( eResult == ChunkFile_EOF ) );
}
ChunkFileResult_t LoadSideCallback(CChunkFile *pFile, LoadSide_t *pSideInfo)
{
return g_LoadingMap->LoadSideCallback( pFile, pSideInfo );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
// pParent -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapFile::LoadSideCallback(CChunkFile *pFile, LoadSide_t *pSideInfo)
{
if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
{
g_MapError.ReportError ("MAX_MAP_BRUSHSIDES");
}
pSideInfo->pSide = &brushsides[nummapbrushsides];
side_t *side = pSideInfo->pSide;
mapbrush_t *b = pSideInfo->pBrush;
g_MapError.BrushSide( pSideInfo->nSideIndex++ );
// initialize the displacement info
pSideInfo->pSide->pMapDisp = NULL;
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler( "dispinfo", ( ChunkHandler_t )LoadDispInfoCallback, &side->pMapDisp );
//
// Read the side chunk.
//
pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadSideKeyCallback, pSideInfo);
pFile->PopHandlers();
if (eResult == ChunkFile_Ok)
{
side->contents |= pSideInfo->nBaseContents;
side->surf |= pSideInfo->nBaseFlags;
pSideInfo->td.flags |= pSideInfo->nBaseFlags;
if (side->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )
{
side->contents |= CONTENTS_DETAIL;
}
if (fulldetail )
{
side->contents &= ~CONTENTS_DETAIL;
}
if (!(side->contents & (ALL_VISIBLE_CONTENTS | CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) ) )
{
side->contents |= CONTENTS_SOLID;
}
// hints and skips are never detail, and have no content
if (side->surf & (SURF_HINT|SURF_SKIP) )
{
side->contents = 0;
}
//
// find the plane number
//
int planenum = PlaneFromPoints(pSideInfo->planepts[0], pSideInfo->planepts[1], pSideInfo->planepts[2]);
if (planenum != -1)
{
//
// See if the plane has been used already.
//
int k;
for ( k = 0; k < b->numsides; k++)
{
side_t *s2 = b->original_sides + k;
if (s2->planenum == planenum)
{
g_MapError.ReportWarning("duplicate plane");
break;
}
if ( s2->planenum == (planenum^1) )
{
g_MapError.ReportWarning("mirrored plane");
break;
}
}
//
// If the plane hasn't been used already, keep this side.
//
if (k == b->numsides)
{
side = b->original_sides + b->numsides;
side->planenum = planenum;
if ( !onlyents )
{
side->texinfo = TexinfoForBrushTexture (&mapplanes[planenum], &pSideInfo->td, vec3_origin);
}
// save the td off in case there is an origin brush and we
// have to recalculate the texinfo
if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
g_MapError.ReportError ("MAX_MAP_BRUSHSIDES");
side_brushtextures[nummapbrushsides] = pSideInfo->td;
nummapbrushsides++;
b->numsides++;
#ifdef VSVMFIO
// Tell Maya We Have Another Side
if ( CVmfImport::GetVmfImporter() )
{
CVmfImport::GetVmfImporter()->AddSideCallback(
b, side, pSideInfo->td,
pSideInfo->planepts[ 0 ], pSideInfo->planepts[ 1 ], pSideInfo->planepts[ 2 ] );
}
#endif // VSVMFIO
}
}
else
{
g_MapError.ReportWarning("plane with no normal");
}
}
return(eResult);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : szKey -
// szValue -
// pSideInfo -
// Output :
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadSideKeyCallback(const char *szKey, const char *szValue, LoadSide_t *pSideInfo)
{
if (!stricmp(szKey, "plane"))
{
int nRead = sscanf(szValue, "(%f %f %f) (%f %f %f) (%f %f %f)",
&pSideInfo->planepts[0][0], &pSideInfo->planepts[0][1], &pSideInfo->planepts[0][2],
&pSideInfo->planepts[1][0], &pSideInfo->planepts[1][1], &pSideInfo->planepts[1][2],
&pSideInfo->planepts[2][0], &pSideInfo->planepts[2][1], &pSideInfo->planepts[2][2]);
if (nRead != 9)
{
g_MapError.ReportError("parsing plane definition");
}
}
else if (!stricmp(szKey, "material"))
{
// Get the material name.
if( g_ReplaceMaterials )
{
szValue = ReplaceMaterialName( szValue );
}
strcpy(pSideInfo->td.name, szValue);
g_MapError.TextureState(szValue);
// Find default flags and values for this material.
int mt = FindMiptex(pSideInfo->td.name);
pSideInfo->td.flags = textureref[mt].flags;
pSideInfo->td.lightmapWorldUnitsPerLuxel = textureref[mt].lightmapWorldUnitsPerLuxel;
pSideInfo->pSide->contents = textureref[mt].contents;
pSideInfo->pSide->surf = pSideInfo->td.flags;
}
else if (!stricmp(szKey, "uaxis"))
{
int nRead = sscanf(szValue, "[%f %f %f %f] %f", &pSideInfo->td.UAxis[0], &pSideInfo->td.UAxis[1], &pSideInfo->td.UAxis[2], &pSideInfo->td.shift[0], &pSideInfo->td.textureWorldUnitsPerTexel[0]);
if (nRead != 5)
{
g_MapError.ReportError("parsing U axis definition");
}
}
else if (!stricmp(szKey, "vaxis"))
{
int nRead = sscanf(szValue, "[%f %f %f %f] %f", &pSideInfo->td.VAxis[0], &pSideInfo->td.VAxis[1], &pSideInfo->td.VAxis[2], &pSideInfo->td.shift[1], &pSideInfo->td.textureWorldUnitsPerTexel[1]);
if (nRead != 5)
{
g_MapError.ReportError("parsing V axis definition");
}
}
else if (!stricmp(szKey, "lightmapscale"))
{
pSideInfo->td.lightmapWorldUnitsPerLuxel = atoi(szValue);
if (pSideInfo->td.lightmapWorldUnitsPerLuxel == 0.0f)
{
g_MapError.ReportWarning("luxel size of 0");
pSideInfo->td.lightmapWorldUnitsPerLuxel = g_defaultLuxelSize;
}
pSideInfo->td.lightmapWorldUnitsPerLuxel *= g_luxelScale;
if (pSideInfo->td.lightmapWorldUnitsPerLuxel < g_minLuxelScale)
{
pSideInfo->td.lightmapWorldUnitsPerLuxel = g_minLuxelScale;
}
}
else if (!stricmp(szKey, "contents"))
{
pSideInfo->pSide->contents |= atoi(szValue);
}
else if (!stricmp(szKey, "flags"))
{
pSideInfo->td.flags |= atoi(szValue);
pSideInfo->pSide->surf = pSideInfo->td.flags;
}
else if (!stricmp(szKey, "id"))
{
pSideInfo->pSide->id = atoi( szValue );
}
else if (!stricmp(szKey, "smoothing_groups"))
{
pSideInfo->pSide->smoothingGroups = atoi( szValue );
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose: Reads the connections chunk of the entity.
// Input : pFile - Chunk file to load from.
// pLoadEntity - Structure to receive loaded entity information.
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadConnectionsCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity)
{
return(pFile->ReadChunk((KeyHandler_t)LoadConnectionsKeyCallback, pLoadEntity));
}
//-----------------------------------------------------------------------------
// Purpose: Parses a key/value pair from the entity connections chunk.
// Input : szKey - Key indicating the name of the entity output.
// szValue - Comma delimited fields in the following format:
// <target>,<input>,<parameter>,<delay>,<times to fire>
// pLoadEntity - Structure to receive loaded entity information.
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadConnectionsKeyCallback(const char *szKey, const char *szValue, LoadEntity_t *pLoadEntity)
{
return g_LoadingMap->LoadConnectionsKeyCallback( szKey, szValue, pLoadEntity );
}
ChunkFileResult_t CMapFile::LoadConnectionsKeyCallback(const char *szKey, const char *szValue, LoadEntity_t *pLoadEntity)
{
//
// Create new input and fill it out.
//
epair_t *pOutput = new epair_t;
pOutput->key = new char [strlen(szKey) + 1];
pOutput->value = new char [strlen(szValue) + 1];
strcpy(pOutput->key, szKey);
strcpy(pOutput->value, szValue);
m_ConnectionPairs = new CConnectionPairs( pOutput, m_ConnectionPairs );
//
// Append it to the end of epairs list.
//
pOutput->next = NULL;
if (!pLoadEntity->pEntity->epairs)
{
pLoadEntity->pEntity->epairs = pOutput;
}
else
{
epair_t *ep;
for ( ep = pLoadEntity->pEntity->epairs; ep->next != NULL; ep = ep->next )
{
}
ep->next = pOutput;
}
return(ChunkFile_Ok);
}
ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity)
{
return g_LoadingMap->LoadSolidCallback( pFile, pLoadEntity );
};
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
// pParent -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapFile::LoadSolidCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity)
{
if (nummapbrushes == MAX_MAP_BRUSHES)
{
g_MapError.ReportError ("nummapbrushes == MAX_MAP_BRUSHES");
}
mapbrush_t *b = &mapbrushes[nummapbrushes];
b->original_sides = &brushsides[nummapbrushsides];
b->entitynum = num_entities-1;
b->brushnum = nummapbrushes - pLoadEntity->pEntity->firstbrush;
LoadSide_t SideInfo;
SideInfo.pBrush = b;
SideInfo.nSideIndex = 0;
SideInfo.nBaseContents = pLoadEntity->nBaseContents;
SideInfo.nBaseFlags = pLoadEntity->nBaseFlags;
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler("side", (ChunkHandler_t)::LoadSideCallback, &SideInfo);
//
// Read the solid chunk.
//
pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadSolidKeyCallback, b);
pFile->PopHandlers();
if (eResult == ChunkFile_Ok)
{
// get the content for the entire brush
b->contents = BrushContents (b);
// allow detail brushes to be removed
if (nodetail && (b->contents & CONTENTS_DETAIL) && !HasDispInfo( b ) )
{
b->numsides = 0;
return(ChunkFile_Ok);
}
// allow water brushes to be removed
if (nowater && (b->contents & MASK_WATER) )
{
b->numsides = 0;
return(ChunkFile_Ok);
}
// create windings for sides and bounds for brush
MakeBrushWindings (b);
//
// brushes that will not be visible at all will never be
// used as bsp splitters
//
// only do this on the world entity
//
if ( b->entitynum == 0 )
{
if (b->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )
{
if ( g_ClipTexinfo < 0 )
{
g_ClipTexinfo = b->original_sides[0].texinfo;
}
c_clipbrushes++;
for (int i=0 ; i<b->numsides ; i++)
{
b->original_sides[i].texinfo = TEXINFO_NODE;
}
}
}
//
// origin brushes are removed, but they set
// the rotation origin for the rest of the brushes
// in the entity. After the entire entity is parsed,
// the planenums and texinfos will be adjusted for
// the origin brush
//
if (b->contents & CONTENTS_ORIGIN)
{
char string[32];
Vector origin;
if (num_entities == 1)
{
Error("Brush %i: origin brushes not allowed in world", b->id);
}
VectorAdd (b->mins, b->maxs, origin);
VectorScale (origin, 0.5, origin);
sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
SetKeyValue (&entities[b->entitynum], "origin", string);
VectorCopy (origin, entities[b->entitynum].origin);
// don't keep this brush
b->numsides = 0;
return(ChunkFile_Ok);
}
#ifdef VSVMFIO
if ( CVmfImport::GetVmfImporter() )
{
CVmfImport::GetVmfImporter()->MapBrushToMayaCallback( b );
}
#endif // VSVMFIO
//
// find a map brushes with displacement surfaces and remove them from the "world"
//
if( HasDispInfo( b ) )
{
// add the base face data to the displacement surface
DispGetFaceInfo( b );
// don't keep this brush
b->numsides = 0;
return( ChunkFile_Ok );
}
AddBrushBevels (b);
nummapbrushes++;
pLoadEntity->pEntity->numbrushes++;
}
else
{
return eResult;
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
// parent -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t LoadSolidKeyCallback(const char *szKey, const char *szValue, mapbrush_t *pLoadBrush)
{
if (!stricmp(szKey, "id"))
{
pLoadBrush->id = atoi(szValue);
g_MapError.BrushState(pLoadBrush->id);
}
return ChunkFile_Ok;
}
/*
================
TestExpandBrushes
Expands all the brush planes and saves a new map out
================
*/
void CMapFile::TestExpandBrushes (void)
{
FILE *f;
side_t *s;
int i, j, bn;
winding_t *w;
char *name = "expanded.map";
mapbrush_t *brush;
vec_t dist;
Msg ("writing %s\n", name);
f = fopen (name, "wb");
if (!f)
Error ("Can't write %s\b", name);
fprintf (f, "{\n\"classname\" \"worldspawn\"\n");
fprintf( f, "\"mapversion\" \"220\"\n\"sounds\" \"1\"\n\"MaxRange\" \"4096\"\n\"mapversion\" \"220\"\n\"wad\" \"vert.wad;dev.wad;generic.wad;spire.wad;urb.wad;cit.wad;water.wad\"\n" );
for (bn=0 ; bn<nummapbrushes ; bn++)
{
brush = &mapbrushes[bn];
fprintf (f, "{\n");
for (i=0 ; i<brush->numsides ; i++)
{
s = brush->original_sides + i;
dist = mapplanes[s->planenum].dist;
for (j=0 ; j<3 ; j++)
dist += fabs( 16 * mapplanes[s->planenum].normal[j] );
w = BaseWindingForPlane (mapplanes[s->planenum].normal, dist);
fprintf (f,"( %i %i %i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2]);
fprintf (f,"( %i %i %i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2]);
fprintf (f,"( %i %i %i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]);
fprintf (f, "%s [ 0 0 1 -512 ] [ 0 -1 0 -256 ] 0 1 1 \n",
TexDataStringTable_GetString( GetTexData( texinfo[s->texinfo].texdata )->nameStringTableID ) );
FreeWinding (w);
}
fprintf (f, "}\n");
}
fprintf (f, "}\n");
fclose (f);
Error ("can't proceed after expanding brushes");
}
//-----------------------------------------------------------------------------
// Purpose: load in the displacement info "chunk" from the .map file into the
// vbsp map displacement info data structure
// Output: return the pointer to the displacement map
//-----------------------------------------------------------------------------
mapdispinfo_t *ParseDispInfoChunk( void )
{
int i, j;
int vertCount;
mapdispinfo_t *pMapDispInfo;
//
// check to see if we exceeded the maximum displacement info list size
//
if( nummapdispinfo > MAX_MAP_DISPINFO )
g_MapError.ReportError( "ParseDispInfoChunk: nummapdispinfo > MAX_MAP_DISPINFO");
// get a pointer to the next available displacement info slot
pMapDispInfo = &mapdispinfo[nummapdispinfo];
nummapdispinfo++;
//
// get the chunk opener - "{"
//
GetToken( false );
if( strcmp( token, "{" ) )
g_MapError.ReportError( "ParseDispInfoChunk: Illegal Chunk! - {" );
//
//
// get the displacement info attribs
//
//
// power
GetToken( true );
pMapDispInfo->power = atoi( token );
// u and v mapping axes
for( i = 0; i < 2; i++ )
{
GetToken( false );
if( strcmp( token, "[" ) )
g_MapError.ReportError( "ParseDispInfoChunk: Illegal Chunk! - [" );
for( j = 0; j < 3; j++ )
{
GetToken( false );
if( i == 0 )
{
pMapDispInfo->uAxis[j] = atof( token );
}
else
{
pMapDispInfo->vAxis[j] = atof( token );
}
}
GetToken( false );
if( strcmp( token, "]" ) )
g_MapError.ReportError( "ParseDispInfoChunk: Illegal Chunk! - ]" );
}
// max displacement value
if( g_nMapFileVersion < 350 )
{
GetToken( false );
pMapDispInfo->maxDispDist = atof( token );
}
// minimum tesselation value
GetToken( false );
pMapDispInfo->minTess = atoi( token );
// light smoothing angle
GetToken( false );
pMapDispInfo->smoothingAngle = atof( token );
//
// get the displacement info displacement normals
//
GetToken( true );
pMapDispInfo->vectorDisps[0][0] = atof( token );
GetToken( false );
pMapDispInfo->vectorDisps[0][1] = atof( token );
GetToken( false );
pMapDispInfo->vectorDisps[0][2] = atof( token );
vertCount = ( ( ( 1 << pMapDispInfo->power ) + 1 ) * ( ( 1 << pMapDispInfo->power ) + 1 ) );
for( i = 1; i < vertCount; i++ )
{
GetToken( false );
pMapDispInfo->vectorDisps[i][0] = atof( token );
GetToken( false );
pMapDispInfo->vectorDisps[i][1] = atof( token );
GetToken( false );
pMapDispInfo->vectorDisps[i][2] = atof( token );
}
//
// get the displacement info displacement values
//
GetToken( true );
pMapDispInfo->dispDists[0] = atof( token );
for( i = 1; i < vertCount; i++ )
{
GetToken( false );
pMapDispInfo->dispDists[i] = atof( token );
}
//
// get the chunk closer - "}"
//
GetToken( true );
if( strcmp( token, "}" ) )
g_MapError.ReportError( "ParseDispInfoChunk: Illegal Chunk! - }" );
// return the index of the displacement info slot
return pMapDispInfo;
}