BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/utils/vbsp/map.cpp

3305 lines
92 KiB
C++
Raw Permalink Blame History

//========= 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;
}
Reference in New Issue View Git Blame Copy Permalink