{

plane_t *hash_chain;

plane_t() { normal.Init(); }

{

Vector UAxis;

Vector VAxis;

vec_t shift[2];

vec_t rotate;

vec_t textureWorldUnitsPerTexel[2];

vec_t lightmapWorldUnitsPerLuxel;

char name[TEXTURE_NAME_LENGTH];

int flags;

brush_texture_t() : UAxis(0,0,0), VAxis(0,0,0) {}

{

int planenum;

int texinfo;

mapdispinfo_t *pMapDisp;

winding_t *winding;

side_t *original; // bspbrush_t sides will reference the mapbrush_t sides

int contents; // from miptex

int surf; // from miptex

qboolean visible; // choose visble planes first

qboolean tested; // this plane allready checked as a split

qboolean bevel; // don't ever use for bsp splitting

side_t *next;

int origIndex;

int id; // This is the unique id generated by worldcraft for this side.

unsigned int smoothingGroups;

CUtlVector<int> aOverlayIds; // List of overlays that reside on this side.

CUtlVector<int> aWaterOverlayIds; // List of water overlays that reside on this side.

bool m_bDynamicShadowsEnabled; // Goes into dface_t::SetDynamicShadowsEnabled().

{

int entitynum;

int brushnum;

int id; // The unique ID of this brush in the editor, used for reporting errors.

int contents;

Vector mins, maxs;

int numsides;

side_t *original_sides;

{

int id;

face_t *next; // on node

// the chain of faces off of a node can be merged or split,

// but each face_t along the way will remain in the chain

// until the entire tree is freed

face_t *merged; // if set, this face isn't valid anymore

face_t *split[2]; // if set, this face isn't valid anymore

portal_t *portal;

int texinfo;

int dispinfo;

// This is only for surfaces that are the boundaries of fog volumes

// (ie. water surfaces)

// All of the rest of the surfaces can look at their leaf to find out

// what fog volume they are in.

node_t *fogVolumeLeaf;

int planenum;

int contents; // faces in different contents can't merge

int outputnumber;

winding_t *w;

int numpoints;

qboolean badstartvert; // tjunctions cannot be fixed without a midpoint vertex

int vertexnums[MAXEDGES];

side_t *originalface; // save the "side" this face came from

int firstPrimID;

int numPrims;

unsigned int smoothingGroups;

{

face_t face;

int entitynum;

int power;

int minTess;

float smoothingAngle;

Vector uAxis;

Vector vAxis;

Vector startPosition;

float alphaValues[MAX_DISPVERTS];

float maxDispDist;

float dispDists[MAX_DISPVERTS];

Vector vectorDisps[MAX_DISPVERTS];

Vector vectorOffsets[MAX_DISPVERTS];

int contents;

int brushSideID;

unsigned short triTags[MAX_DISPTRIS];

int flags;

#ifdef VSVMFIO

float m_elevation; // "elevation"

Vector m_offsetNormals[ MAX_DISPTRIS ]; // "offset_normals"

#endif // VSVMFIO

{

int id;

bspbrush_t *next;

Vector mins, maxs;

int side, testside; // side of node during construction

mapbrush_t *original;

int numsides;

side_t sides[6]; // variably sized

{

face_t *pFace;

leafface_t *pNext;

{

int id;

// both leafs and nodes

int planenum; // -1 = leaf node

node_t *parent;

Vector mins, maxs; // valid after portalization

bspbrush_t *volume; // one for each leaf/node

// nodes only

side_t *side; // the side that created the node

node_t *children[2];

face_t *faces; // these are the cutup ones that live in the plane of "side".

// leafs only

bspbrush_t *brushlist; // fragments of all brushes in this leaf

leafface_t *leaffacelist;

int contents; // OR of all brush contents

int occupied; // 1 or greater can reach entity

entity_t *occupant; // for leak file testing

int cluster; // for portalfile writing

int area; // for areaportals

portal_t *portals; // also on nodes during construction

int diskId; // dnodes or dleafs index after this has been emitted

{

int id;

plane_t plane;

node_t *onnode; // NULL = outside box

node_t *nodes[2]; // [0] = front side of plane

portal_t *next[2];

winding_t *winding;

qboolean sidefound; // false if ->side hasn't been checked

side_t *side; // NULL = non-visible

face_t *face[2]; // output face in bsp file

{

node_t *headnode;

node_t outside_node;

Vector mins, maxs;

bool leaked;

{

public:

CMapFile( void ) { Init(); }

void Init( void );

void AddPlaneToHash (plane_t *p);

int CreateNewFloatPlane (Vector& normal, vec_t dist);

int FindFloatPlane (Vector& normal, vec_t dist);

int PlaneFromPoints(const Vector &p0, const Vector &p1, const Vector &p2);

void AddBrushBevels (mapbrush_t *b);

qboolean MakeBrushWindings (mapbrush_t *ob);

void MoveBrushesToWorld( entity_t *mapent );

void MoveBrushesToWorldGeneral( entity_t *mapent );

void RemoveContentsDetailFromEntity( entity_t *mapent );

int SideIDToIndex( int brushSideID );

void AddLadderKeys( entity_t *mapent );

ChunkFileResult_t LoadEntityCallback(CChunkFile *pFile, int nParam);

void ForceFuncAreaPortalWindowContents();

ChunkFileResult_t LoadSideCallback(CChunkFile *pFile, LoadSide_t *pSideInfo);

ChunkFileResult_t LoadConnectionsKeyCallback(const char *szKey, const char *szValue, LoadEntity_t *pLoadEntity);

ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity);

void TestExpandBrushes(void);

static char m_InstancePath[ MAX_PATH ];

static void SetInstancePath( const char *pszInstancePath );

static const char *GetInstancePath( void ) { return m_InstancePath; }

static bool DeterminePath( const char *pszBaseFileName, const char *pszInstanceFileName, char *pszOutFileName );

void CheckForInstances( const char *pszFileName );

void MergeInstance( entity_t *pInstanceEntity, CMapFile *Instance );

void MergePlanes( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix );

void MergeBrushes( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix );

void MergeBrushSides( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix );

void ReplaceInstancePair( epair_t *pPair, entity_t *pInstanceEntity );

void MergeEntities( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix );

void MergeOverlays( entity_t *pInstanceEntity, CMapFile *Instance, Vector &InstanceOrigin, QAngle &InstanceAngle, matrix3x4_t &InstanceMatrix );

static int m_InstanceCount;

static int c_areaportals;

plane_t mapplanes[MAX_MAP_PLANES];

int nummapplanes;

#define PLANE_HASHES 1024

plane_t *planehash[PLANE_HASHES];

int nummapbrushes;

mapbrush_t mapbrushes[MAX_MAP_BRUSHES];

Vector map_mins, map_maxs;

int nummapbrushsides;

side_t brushsides[MAX_MAP_BRUSHSIDES];

brush_texture_t side_brushtextures[MAX_MAP_BRUSHSIDES];

int num_entities;

entity_t entities[MAX_MAP_ENTITIES];

int c_boxbevels;

int c_edgebevels;

int c_clipbrushes;

int g_ClipTexinfo;

class CConnectionPairs

{

public:

CConnectionPairs( epair_t *pair, CConnectionPairs *next )

{

m_Pair = pair;

m_Next = next;

}

epair_t *m_Pair;

CConnectionPairs *m_Next;

};

CConnectionPairs *m_ConnectionPairs;

int m_StartMapOverlays;

int m_StartMapWaterOverlays;

{

char name[TEXTURE_NAME_LENGTH];

int flags;

float lightmapWorldUnitsPerLuxel;

int contents;

{

FULL_DETAIL = 0,

ONLY_DETAIL = 1,

NO_DETAIL = 2,

{

int nId;

unsigned short m_nRenderOrder;

char szMaterialName[OVERLAY_MAP_STRLEN];

float flU[2];

float flV[2];

float flFadeDistMinSq;

float flFadeDistMaxSq;

Vector vecUVPoints[4];

Vector vecOrigin;

Vector vecBasis[3];

CUtlVector<int> aSideList;

CUtlVector<int> aFaceList;