//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $Workfile: $ // $Date: $ // $NoKeywords: $ //=============================================================================// #ifndef BSPLIB_H #define BSPLIB_H #ifdef _WIN32 #pragma once #endif #include "bspfile.h" #include "byteswap.h" #include "utllinkedlist.h" #include "utlstring.h" #include "utlvector.h" #include "zip_utils.h" #ifdef ENGINE_DLL #include "zone.h" #endif #ifdef ENGINE_DLL typedef CUtlVector > CDispLightmapSamplePositions; #else typedef CUtlVector CDispLightmapSamplePositions; #endif class ISpatialQuery; struct Ray_t; class Vector2D; struct portal_t; class CUtlBuffer; class IZip; // this is only true in vrad extern bool g_bHDR; // default width/height of luxels in world units. #define DEFAULT_LUXEL_SIZE (16.0f) #define SINGLE_BRUSH_MAP \ (MAX_BRUSH_LIGHTMAP_DIM_INCLUDING_BORDER * \ MAX_BRUSH_LIGHTMAP_DIM_INCLUDING_BORDER) #define SINGLEMAP \ (MAX_LIGHTMAP_DIM_INCLUDING_BORDER * MAX_LIGHTMAP_DIM_INCLUDING_BORDER) struct entity_t { Vector origin; int firstbrush; int numbrushes; epair_t *epairs; // only valid for func_areaportals int areaportalnum; int portalareas[2]; portal_t *m_pPortalsLeadingIntoAreas[2]; // portals leading into portalareas }; extern int num_entities; extern entity_t entities[MAX_MAP_ENTITIES]; extern int nummodels; extern dmodel_t dmodels[MAX_MAP_MODELS]; extern int visdatasize; extern byte dvisdata[MAX_MAP_VISIBILITY]; extern dvis_t *dvis; extern CUtlVector dlightdataHDR; extern CUtlVector dlightdataLDR; extern CUtlVector *pdlightdata; extern CUtlVector dentdata; extern int numleafs; #if !defined(_X360) extern dleaf_t dleafs[MAX_MAP_LEAFS]; #else extern dleaf_t *dleafs; #endif extern CUtlVector *g_pLeafAmbientLighting; extern CUtlVector *g_pLeafAmbientIndex; extern unsigned short g_LeafMinDistToWater[MAX_MAP_LEAFS]; extern int numplanes; extern dplane_t dplanes[MAX_MAP_PLANES]; extern int numvertexes; extern dvertex_t dvertexes[MAX_MAP_VERTS]; extern int g_numvertnormalindices; // dfaces reference these. These index // g_vertnormals. extern unsigned short g_vertnormalindices[MAX_MAP_VERTNORMALS]; extern int g_numvertnormals; extern Vector g_vertnormals[MAX_MAP_VERTNORMALS]; extern int numnodes; extern dnode_t dnodes[MAX_MAP_NODES]; extern CUtlVector texinfo; extern int numtexdata; extern dtexdata_t dtexdata[MAX_MAP_TEXDATA]; // displacement map .bsp file info extern CUtlVector g_dispinfo; extern CUtlVector g_DispVerts; extern CUtlVector g_DispTris; extern CDispLightmapSamplePositions g_DispLightmapSamplePositions; // LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS extern int numorigfaces; extern dface_t dorigfaces[MAX_MAP_FACES]; extern int g_numprimitives; extern dprimitive_t g_primitives[MAX_MAP_PRIMITIVES]; extern int g_numprimverts; extern dprimvert_t g_primverts[MAX_MAP_PRIMVERTS]; extern int g_numprimindices; extern unsigned short g_primindices[MAX_MAP_PRIMINDICES]; extern int numfaces; extern dface_t dfaces[MAX_MAP_FACES]; extern int numfaceids; extern CUtlVector dfaceids; extern int numfaces_hdr; extern dface_t dfaces_hdr[MAX_MAP_FACES]; extern int numedges; extern dedge_t dedges[MAX_MAP_EDGES]; extern int numleaffaces; extern unsigned short dleaffaces[MAX_MAP_LEAFFACES]; extern int numleafbrushes; extern unsigned short dleafbrushes[MAX_MAP_LEAFBRUSHES]; extern int numsurfedges; extern int dsurfedges[MAX_MAP_SURFEDGES]; extern int numareas; extern darea_t dareas[MAX_MAP_AREAS]; extern int numareaportals; extern dareaportal_t dareaportals[MAX_MAP_AREAPORTALS]; extern int numbrushes; extern dbrush_t dbrushes[MAX_MAP_BRUSHES]; extern int numbrushsides; extern dbrushside_t dbrushsides[MAX_MAP_BRUSHSIDES]; extern int *pNumworldlights; extern dworldlight_t *dworldlights; extern Vector g_ClipPortalVerts[MAX_MAP_PORTALVERTS]; extern int g_nClipPortalVerts; extern dcubemapsample_t g_CubemapSamples[MAX_MAP_CUBEMAPSAMPLES]; extern int g_nCubemapSamples; extern int g_nOverlayCount; extern doverlay_t g_Overlays[MAX_MAP_OVERLAYS]; extern doverlayfade_t g_OverlayFades[MAX_MAP_OVERLAYS]; // Parallel array of fade info in a // separate lump to avoid breaking // backwards compat extern int g_nWaterOverlayCount; extern dwateroverlay_t g_WaterOverlays[MAX_MAP_WATEROVERLAYS]; extern CUtlVector g_TexDataStringData; extern CUtlVector g_TexDataStringTable; extern int numleafwaterdata; extern dleafwaterdata_t dleafwaterdata[MAX_MAP_LEAFWATERDATA]; extern CUtlVector g_FaceMacroTextureInfos; extern CUtlVector g_OccluderData; extern CUtlVector g_OccluderPolyData; extern CUtlVector g_OccluderVertexIndices; // level flags - see LVLFLAGS_xxx in bspfile.h extern uint32 g_LevelFlags; // physics collision data extern byte *g_pPhysCollide; extern int g_PhysCollideSize; extern byte *g_pPhysDisp; extern int g_PhysDispSize; // Embedded pack/pak file IZip *GetPakFile(void); IZip *GetSwapPakFile(void); void ClearPakFile(IZip *pak); void AddFileToPak( IZip *pak, const char *pRelativeName, const char *fullpath, IZip::eCompressionType compressionType = IZip::eCompressionType_None); void AddBufferToPak( IZip *pak, const char *pRelativeName, void *data, int length, bool bTextMode, IZip::eCompressionType compressionType = IZip::eCompressionType_None); void AddDirToPak(IZip *pak, const char *pDirPath, const char *pPakPrefix = NULL); bool FileExistsInPak(IZip *pak, const char *pRelativeName); bool ReadFileFromPak(IZip *pak, const char *pRelativeName, bool bTextMode, CUtlBuffer &buf); void RemoveFileFromPak(IZip *pak, const char *pRelativeName); int GetNextFilename(IZip *pak, int id, char *pBuffer, int bufferSize, int &fileSize); void ForceAlignment(IZip *pak, bool bAlign, bool bCompatibleFormat, unsigned int alignmentSize); typedef bool (*CompressFunc_t)(CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer); typedef bool (*VTFConvertFunc_t)(const char *pDebugName, CUtlBuffer &sourceBuf, CUtlBuffer &targetBuf, CompressFunc_t pCompressFunc); typedef bool (*VHVFixupFunc_t)(const char *pVhvFilename, const char *pModelName, CUtlBuffer &sourceBuf, CUtlBuffer &targetBuf); //----------------------------------------------------------------------------- // Game lump memory storage //----------------------------------------------------------------------------- // NOTE: This is not optimal at all; since I expect client lumps to // not be accessed all that often. struct GameLump_t { GameLumpId_t m_Id; unsigned short m_Flags; unsigned short m_Version; CUtlMemory m_Memory; }; //----------------------------------------------------------------------------- // Handle to a game lump //----------------------------------------------------------------------------- typedef unsigned short GameLumpHandle_t; class CGameLump { public: //----------------------------------------------------------------------------- // Convert four-CC code to a handle + back //----------------------------------------------------------------------------- GameLumpHandle_t GetGameLumpHandle(GameLumpId_t id); GameLumpId_t GetGameLumpId(GameLumpHandle_t handle); int GetGameLumpFlags(GameLumpHandle_t handle); int GetGameLumpVersion(GameLumpHandle_t handle); void ComputeGameLumpSizeAndCount(int &size, int &clumpCount); void ParseGameLump(dheader_t *pHeader); void SwapGameLump(GameLumpId_t id, int version, byte *dest, byte *src, int size); //----------------------------------------------------------------------------- // Game lump accessor methods //----------------------------------------------------------------------------- void *GetGameLump(GameLumpHandle_t handle); int GameLumpSize(GameLumpHandle_t handle); //----------------------------------------------------------------------------- // Game lump iteration methods //----------------------------------------------------------------------------- GameLumpHandle_t FirstGameLump(); GameLumpHandle_t NextGameLump(GameLumpHandle_t handle); GameLumpHandle_t InvalidGameLump(); //----------------------------------------------------------------------------- // Game lump creation/destruction method //----------------------------------------------------------------------------- GameLumpHandle_t CreateGameLump(GameLumpId_t id, int size, int flags, int version); void DestroyGameLump(GameLumpHandle_t handle); void DestroyAllGameLumps(); private: CUtlLinkedList m_GameLumps; }; extern CGameLump g_GameLumps; extern CByteswap g_Swap; //----------------------------------------------------------------------------- // Helper for the bspzip tool //----------------------------------------------------------------------------- void ExtractZipFileFromBSP(char *pBSPFileName, char *pZipFileName); //----------------------------------------------------------------------------- // String table methods //----------------------------------------------------------------------------- const char *TexDataStringTable_GetString(int stringID); int TexDataStringTable_AddOrFindString(const char *pString); void DecompressVis(byte *in, byte *decompressed); int CompressVis(byte *vis, byte *dest); void OpenBSPFile(const char *filename); void CloseBSPFile(void); void LoadBSPFile(const char *filename); void LoadBSPFile_FileSystemOnly(const char *filename); void LoadBSPFileTexinfo(const char *filename); void WriteBSPFile(const char *filename, char *pUnused = NULL); void PrintBSPFileSizes(void); void PrintBSPPackDirectory(void); void ReleasePakFileLumps(void); bool RepackBSPCallback_LZMA(CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer); bool RepackBSP(CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer, CompressFunc_t pCompressFunc, IZip::eCompressionType packfileCompression); bool SwapBSPFile(const char *filename, const char *swapFilename, bool bSwapOnLoad, VTFConvertFunc_t pVTFConvertFunc, VHVFixupFunc_t pVHVFixupFunc, CompressFunc_t pCompressFunc); bool GetPakFileLump(const char *pBSPFilename, void **pPakData, int *pPakSize); bool SetPakFileLump(const char *pBSPFilename, const char *pNewFilename, void *pPakData, int pakSize); void WriteLumpToFile(char *filename, int lump); void WriteLumpToFile(char *filename, int lump, int nLumpVersion, void *pBuffer, size_t nBufLen); bool GetBSPDependants(const char *pBSPFilename, CUtlVector *pList); void UnloadBSPFile(); void ParseEntities(void); void UnparseEntities(void); void PrintEntity(entity_t *ent); void SetKeyValue(entity_t *ent, const char *key, const char *value); char *ValueForKey(entity_t *ent, char *key); // will return "" if not present int IntForKey(entity_t *ent, char *key); int IntForKeyWithDefault(entity_t *ent, char *key, int nDefault); vec_t FloatForKey(entity_t *ent, char *key); vec_t FloatForKeyWithDefault(entity_t *ent, char *key, float default_value); void GetVectorForKey(entity_t *ent, char *key, Vector &vec); void GetVector2DForKey(entity_t *ent, char *key, Vector2D &vec); void GetAnglesForKey(entity_t *ent, char *key, QAngle &vec); epair_t *ParseEpair(void); void StripTrailing(char *e); // Build a list of the face's vertices (index into dvertexes). // points must be able to hold pFace->numedges indices. void BuildFaceCalcWindingData(dface_t *pFace, int *points); // Convert a tristrip to a trilist. // Removes degenerates. // Fills in pTriListIndices and pnTriListIndices. // You must free pTriListIndices with delete[]. void TriStripToTriList(unsigned short const *pTriStripIndices, int nTriStripIndices, unsigned short **pTriListIndices, int *pnTriListIndices); // Calculates the lightmap coordinates at a given set of positions given the // lightmap basis information. void CalcTextureCoordsAtPoints(float const texelsPerWorldUnits[2][4], int const subtractOffset[2], Vector const *pPoints, int const nPoints, Vector2D *pCoords); // Figure out lightmap extents on all (lit) faces. void UpdateAllFaceLightmapExtents(); //----------------------------------------------------------------------------- // Gets at an interface for the tree for enumeration of leaves in volumes. //----------------------------------------------------------------------------- ISpatialQuery *ToolBSPTree(); class IBSPNodeEnumerator { public: // call back with a node and a context virtual bool EnumerateNode(int node, Ray_t const &ray, float f, int context) = 0; // call back with a leaf and a context virtual bool EnumerateLeaf(int leaf, Ray_t const &ray, float start, float end, int context) = 0; }; //----------------------------------------------------------------------------- // Enumerates nodes + leafs in front to back order... //----------------------------------------------------------------------------- bool EnumerateNodesAlongRay(Ray_t const &ray, IBSPNodeEnumerator *pEnum, int context); //----------------------------------------------------------------------------- // Helps us find all leaves associated with a particular cluster //----------------------------------------------------------------------------- struct clusterlist_t { int leafCount; CUtlVector leafs; }; extern CUtlVector g_ClusterLeaves; // Call this to build the mapping from cluster to leaves void BuildClusterTable(); void SetHDRMode(bool bHDR); // ----------------------------------------------------------------------------- // // Helper accessors for the various structures. // ----------------------------------------------------------------------------- // // inline ColorRGBExp32 *dface_AvgLightColor(dface_t *pFace, int nLightStyleIndex) { return (ColorRGBExp32 *)&( *pdlightdata)[pFace->lightofs - (nLightStyleIndex + 1) * 4]; } inline const char *TexInfo_TexName(int iTexInfo) { return TexDataStringTable_GetString( dtexdata[texinfo[iTexInfo].texdata].nameStringTableID); } #endif // BSPLIB_H