//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $Workfile: $ // $Date: $ // $NoKeywords: $ //=============================================================================// #ifndef GL_MODEL_PRIVATE_H #define GL_MODEL_PRIVATE_H #ifdef _WIN32 #pragma once #endif #include "mathlib/vector4d.h" #include "tier0/dbg.h" #include "tier1/utlsymbol.h" #include "idispinfo.h" #include "shadowmgr.h" #include "vcollide.h" #include "studio.h" #include "qlimits.h" #include "host.h" #include "gl_model.h" #include "cmodel.h" #include "bspfile.h" #include "Overlay.h" //#include "datamap.h" #include "surfacehandle.h" #include "mathlib/compressed_light_cube.h" #include "datacache/imdlcache.h" #include "bitmap/cubemap.h" #include "memstack.h" //----------------------------------------------------------------------------- // forward declarations //----------------------------------------------------------------------------- struct studiomeshdata_t; struct decal_t; struct msurface1_t; struct msurfacelighting_t; struct msurfacenormal_t; class ITexture; class CEngineSprite; // !!! if this is changed, it must be changed in asm_draw.h too !!! struct mvertex_t { Vector position; }; // !!! if this is changed, it must be changed in asm_draw.h too !!! struct medge_t { unsigned short v[2]; // unsigned int cachededgeoffset; }; class IMaterial; class IMaterialVar; // This is here for b/w compatibility with world surfaces that use // WorldVertexTransition. We can get rid of it when we rev the engine. #define TEXINFO_USING_BASETEXTURE2 0x0001 struct mtexinfo_t { Vector4D textureVecsTexelsPerWorldUnits[2]; // [s/t] unit vectors in world space. // [i][3] is the s/t offset relative to the origin. Vector4D lightmapVecsLuxelsPerWorldUnits[2]; float luxelsPerWorldUnit; float worldUnitsPerLuxel; unsigned short flags; // SURF_ flags. unsigned short texinfoFlags;// TEXINFO_ flags. IMaterial *material; mtexinfo_t( mtexinfo_t const& src ) { // copy constructor needed since Vector4D has no copy constructor memcpy( this, &src, sizeof(mtexinfo_t) ); } }; struct mnode_t { // common with leaf int contents; // <0 to differentiate from leafs // -1 means check the node for visibility // -2 means don't check the node for visibility int visframe; // node needs to be traversed if current mnode_t *parent; short area; // If all leaves below this node are in the same area, then // this is the area index. If not, this is -1. short flags; VectorAligned m_vecCenter; VectorAligned m_vecHalfDiagonal; // node specific cplane_t *plane; mnode_t *children[2]; unsigned short firstsurface; unsigned short numsurfaces; }; struct mleaf_t { public: // common with node int contents; // contents mask int visframe; // node needs to be traversed if current mnode_t *parent; short area; short flags; VectorAligned m_vecCenter; VectorAligned m_vecHalfDiagonal; // leaf specific short cluster; short leafWaterDataID; unsigned short firstmarksurface; unsigned short nummarksurfaces; short nummarknodesurfaces; short unused; unsigned short dispListStart; // index into displist of first displacement unsigned short dispCount; // number of displacements in the list for this leaf }; struct mleafwaterdata_t { float surfaceZ; float minZ; short surfaceTexInfoID; short firstLeafIndex; }; struct mcubemapsample_t { Vector origin; ITexture *pTexture; unsigned char size; // default (mat_envmaptgasize) if 0, 1<<(size-1) otherwise. }; typedef struct mportal_s { unsigned short *vertList; int numportalverts; cplane_t *plane; unsigned short cluster[2]; // int visframe; } mportal_t; typedef struct mcluster_s { unsigned short *portalList; int numportals; } mcluster_t; struct mmodel_t { Vector mins, maxs; Vector origin; // for sounds or lights float radius; int headnode; int firstface, numfaces; }; struct mprimitive_t { int type; unsigned short firstIndex; unsigned short indexCount; unsigned short firstVert; unsigned short vertCount; }; struct mprimvert_t { Vector pos; float texCoord[2]; float lightCoord[2]; }; typedef dleafambientindex_t mleafambientindex_t; typedef dleafambientlighting_t mleafambientlighting_t; struct LightShadowZBufferSample_t { float m_flTraceDistance; // how far we traced. 0 = invalid float m_flHitDistance; // where we hit }; #define SHADOW_ZBUF_RES 8 // 6 * 64 * 2 * 4 = 3k bytes per light typedef CCubeMap< LightShadowZBufferSample_t, SHADOW_ZBUF_RES> lightzbuffer_t; #include "model_types.h" #define MODELFLAG_MATERIALPROXY 0x0001 // we've got a material proxy #define MODELFLAG_TRANSLUCENT 0x0002 // we've got a translucent model #define MODELFLAG_VERTEXLIT 0x0004 // we've got a vertex-lit model #define MODELFLAG_TRANSLUCENT_TWOPASS 0x0008 // render opaque part in opaque pass #define MODELFLAG_FRAMEBUFFER_TEXTURE 0x0010 // we need the framebuffer as a texture #define MODELFLAG_HAS_DLIGHT 0x0020 // need to check dlights #define MODELFLAG_VIEW_WEAPON_MODEL 0x0040 // monitored by weapon model cache #define MODELFLAG_RENDER_DISABLED 0x0080 // excluded for compliance with government regulations #define MODELFLAG_STUDIOHDR_USES_FB_TEXTURE 0x0100 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_USES_BUMPMAPPING 0x0200 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_USES_ENV_CUBEMAP 0x0400 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_AMBIENT_BOOST 0x0800 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_DO_NOT_CAST_SHADOWS 0x1000 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_IS_STATIC_PROP 0x2000 // persisted from studiohdr #define MODELFLAG_STUDIOHDR_BAKED_VERTEX_LIGHTING_IS_INDIRECT_ONLY 0x4000 // persisted from studiohdr struct worldbrushdata_t { int numsubmodels; int nWorldFaceCount; int numplanes; cplane_t *planes; int numleafs; // number of visible leafs, not counting 0 mleaf_t *leafs; int numleafwaterdata; mleafwaterdata_t *leafwaterdata; int numvertexes; mvertex_t *vertexes; int numoccluders; doccluderdata_t *occluders; int numoccluderpolys; doccluderpolydata_t *occluderpolys; int numoccludervertindices; int *occludervertindices; int numvertnormalindices; // These index vertnormals. unsigned short *vertnormalindices; int numvertnormals; Vector *vertnormals; int numnodes; mnode_t *nodes; unsigned short *m_LeafMinDistToWater; int numtexinfo; mtexinfo_t *texinfo; int numtexdata; csurface_t *texdata; int numDispInfos; HDISPINFOARRAY hDispInfos; // Use DispInfo_Index to get IDispInfos.. /* int numOrigSurfaces; msurface_t *pOrigSurfaces; */ int numsurfaces; msurface1_t *surfaces1; msurface2_t *surfaces2; msurfacelighting_t *surfacelighting; msurfacenormal_t *surfacenormals; unsigned short *m_pSurfaceBrushes; dfacebrushlist_t *m_pSurfaceBrushList; int numvertindices; unsigned short *vertindices; int nummarksurfaces; SurfaceHandle_t *marksurfaces; ColorRGBExp32 *lightdata; int m_nLightingDataSize; int numworldlights; dworldlight_t *worldlights; lightzbuffer_t *shadowzbuffers; // non-polygon primitives (strips and lists) int numprimitives; mprimitive_t *primitives; int numprimverts; mprimvert_t *primverts; int numprimindices; unsigned short *primindices; int m_nAreas; darea_t *m_pAreas; int m_nAreaPortals; dareaportal_t *m_pAreaPortals; int m_nClipPortalVerts; Vector *m_pClipPortalVerts; mcubemapsample_t *m_pCubemapSamples; int m_nCubemapSamples; int m_nDispInfoReferences; unsigned short *m_pDispInfoReferences; mleafambientindex_t *m_pLeafAmbient; mleafambientlighting_t *m_pAmbientSamples; // specific technique that discards all the lightmaps after load // no lightstyles or dlights are possible with this technique bool m_bUnloadedAllLightmaps; CMemoryStack *m_pLightingDataStack; int m_nBSPFileSize; #if 0 int numportals; mportal_t *portals; int numclusters; mcluster_t *clusters; int numportalverts; unsigned short *portalverts; int numclusterportals; unsigned short *clusterportals; #endif }; // only models with type "mod_brush" have this data struct brushdata_t { worldbrushdata_t *pShared; int firstmodelsurface; int nummodelsurfaces; // track the union of all lightstyles on this brush. That way we can avoid // searching all faces if the lightstyle hasn't changed since the last update int nLightstyleLastComputedFrame; unsigned short nLightstyleIndex; // g_ModelLoader actually holds the allocated data here unsigned short nLightstyleCount; unsigned short renderHandle; unsigned short firstnode; }; // only models with type "mod_sprite" have this data struct spritedata_t { int numframes; int width; int height; CEngineSprite *sprite; }; struct model_t { FileNameHandle_t fnHandle; char szPathName[MAX_OSPATH]; int nLoadFlags; // mark loaded/not loaded int nServerCount; // marked at load modtype_t type; int flags; // MODELFLAG_??? // volume occupied by the model graphics Vector mins, maxs; float radius; KeyValues *m_pKeyValues; union { brushdata_t brush; MDLHandle_t studio; spritedata_t sprite; }; }; //----------------------------------------------------------------------------- // Decals //----------------------------------------------------------------------------- struct decallist_t { DECLARE_SIMPLE_DATADESC(); Vector position; char name[ 128 ]; short entityIndex; byte depth; byte flags; // This is the surface plane that we hit so that we can move certain decals across // transitions if they hit similar geometry Vector impactPlaneNormal; }; inline class IDispInfo *MLeaf_Disaplcement( mleaf_t *pLeaf, int index, worldbrushdata_t *pData = host_state.worldbrush ) { Assert(indexdispCount); int dispIndex = pData->m_pDispInfoReferences[pLeaf->dispListStart+index]; return DispInfo_IndexArray( pData->hDispInfos, dispIndex ); } #define MAXLIGHTMAPS 4 // drawing surface flags #define SURFDRAW_NOLIGHT 0x00000001 // no lightmap #define SURFDRAW_NODE 0x00000002 // This surface is on a node #define SURFDRAW_SKY 0x00000004 // portal to sky #define SURFDRAW_BUMPLIGHT 0x00000008 // Has multiple lightmaps for bump-mapping #define SURFDRAW_NODRAW 0x00000010 // don't draw this surface, not really visible #define SURFDRAW_TRANS 0x00000020 // sort this surface from back to front #define SURFDRAW_PLANEBACK 0x00000040 // faces away from plane of the node that stores this face #define SURFDRAW_DYNAMIC 0x00000080 // Don't use a static buffer for this face #define SURFDRAW_TANGENTSPACE 0x00000100 // This surface needs a tangent space #define SURFDRAW_NOCULL 0x00000200 // Don't bother backface culling these #define SURFDRAW_HASLIGHTSYTLES 0x00000400 // has a lightstyle other than 0 #define SURFDRAW_HAS_DISP 0x00000800 // has a dispinfo #define SURFDRAW_ALPHATEST 0x00001000 // Is alphstested #define SURFDRAW_NOSHADOWS 0x00002000 // No shadows baby #define SURFDRAW_NODECALS 0x00004000 // No decals baby #define SURFDRAW_HAS_PRIMS 0x00008000 // has a list of prims #define SURFDRAW_WATERSURFACE 0x00010000 // This is a water surface #define SURFDRAW_UNDERWATER 0x00020000 #define SURFDRAW_ABOVEWATER 0x00040000 #define SURFDRAW_HASDLIGHT 0x00080000 // Has some kind of dynamic light that must be checked // BEGIN HACK PORTAL2 #define SURFDRAW_NOPAINT 0x00100000 // nopaint #define SURFDRAW_PAINTED 0x00200000 // painted surface // END HACK PORTAL2 #define SURFDRAW_VERTCOUNT_MASK 0xFF000000 // 8 bits of vertex count #define SURFDRAW_SORTGROUP_MASK 0x00C00000 // 2 bits of sortgroup #define SURFDRAW_VERTCOUNT_SHIFT 24 #define SURFDRAW_SORTGROUP_SHIFT 22 // NOTE: 16-bytes, preserve size/alignment - we index this alot struct msurface1_t { // garymct - are these needed? - used by decal projection code int textureMins[2]; // smallest unnormalized s/t position on the surface. short textureExtents[2]; // ?? s/t texture size, 1..512 for all non-sky surfaces struct { unsigned short numPrims; unsigned short firstPrimID; // index into primitive list if numPrims > 0 } prims; }; struct msurfacenormal_t { unsigned int firstvertnormal; // unsigned short firstvertnormal; // FIXME: Should I just point to the leaf here since it has this data????????????? // short fogVolumeID; // -1 if not in fog }; // This is a single cache line (32 bytes) struct msurfacelighting_t { // You read that minus sign right. See the comment below. ColorRGBExp32 *AvgLightColor( int nLightStyleIndex ) { return m_pSamples - (nLightStyleIndex + 1); } // Lightmap info short m_LightmapMins[2]; short m_LightmapExtents[2]; short m_OffsetIntoLightmapPage[2]; int m_nLastComputedFrame; // last frame the surface's lightmap was recomputed int m_fDLightBits; // Indicates which dlights illuminates this surface. int m_nDLightFrame; // Indicates the last frame in which dlights illuminated this surface unsigned char m_nStyles[MAXLIGHTMAPS]; // index into d_lightstylevalue[] for animated lights // no one surface can be effected by more than 4 // animated lights. // NOTE: This is tricky. To get this to fit in a single cache line, // and to save the extra memory of not having to store average light colors for // lightstyles that are not used, I store between 0 and 4 average light colors +before+ // the samples, depending on how many lightstyles there are. Naturally, accessing // an average color for an undefined lightstyle on the surface results in undefined results. // 0->4 avg light colors, *in reverse order from m_nStyles* + [numstyles*surfsize] ColorRGBExp32 *m_pSamples; }; const int WORLD_DECAL_HANDLE_INVALID = 0xFFFF; typedef unsigned short WorldDecalHandle_t; // NOTE: 32-bytes. Aligned/indexed often struct msurface2_t { unsigned int flags; // see SURFDRAW_ #defines (only 22-bits right now) // These are packed in to flags now //unsigned char vertCount; // number of verts for this surface //unsigned char sortGroup; // only uses 2 bits, subdivide? #ifdef _PS3 cplane_t m_plane; // pointer to shared plane #else cplane_t* plane; // pointer to shared plane #endif int firstvertindex; // look up in model->vertindices[] (only uses 17-18 bits?) WorldDecalHandle_t decals; ShadowDecalHandle_t m_ShadowDecals; // unsigned short OverlayFragmentHandle_t m_nFirstOverlayFragment; // First overlay fragment on the surface (short) short materialSortID; unsigned short vertBufferIndex; unsigned short m_bDynamicShadowsEnabled : 1; // Can this surface receive dynamic shadows? unsigned short texinfo : 15; IDispInfo *pDispInfo; // displacement map information int visframe; // should be drawn when node is crossed }; inline unsigned short MSurf_AreDynamicShadowsEnabled( SurfaceHandle_t surfID ) { return surfID->m_bDynamicShadowsEnabled; } inline int MSurf_Index( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = surfID - pData->surfaces2; Assert(surfaceIndex >= 0 && surfaceIndex < pData->numsurfaces); return surfaceIndex; } inline const SurfaceHandle_t SurfaceHandleFromIndex( int surfaceIndex, const worldbrushdata_t *pData ) { return &pData->surfaces2[surfaceIndex]; } inline SurfaceHandle_t SurfaceHandleFromIndex( int surfaceIndex, worldbrushdata_t *pData = host_state.worldbrush ) { return &pData->surfaces2[surfaceIndex]; } #if _DEBUG #define ASSERT_SURF_VALID(surfID) MSurf_Index(surfID) #else #define ASSERT_SURF_VALID(surfID) #endif inline unsigned int& MSurf_Flags( SurfaceHandle_t surfID ) { return surfID->flags; } inline bool SurfaceHasDispInfo( SurfaceHandle_t surfID ) { return ( MSurf_Flags( surfID ) & SURFDRAW_HAS_DISP ) ? true : false; } inline bool SurfaceHasPrims( SurfaceHandle_t surfID ) { return ( MSurf_Flags( surfID ) & SURFDRAW_HAS_PRIMS ) ? true : false; } inline int& MSurf_VisFrame( SurfaceHandle_t surfID ) { return surfID->visframe; } inline int MSurf_SortGroup( SurfaceHandle_t surfID ) { return (surfID->flags & SURFDRAW_SORTGROUP_MASK) >> SURFDRAW_SORTGROUP_SHIFT; } inline void MSurf_SetSortGroup( SurfaceHandle_t surfID, int sortGroup ) { unsigned int flags = (sortGroup << SURFDRAW_SORTGROUP_SHIFT) & SURFDRAW_SORTGROUP_MASK; surfID->flags |= flags; } /* inline int& MSurf_DLightFrame( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfID].dlightframe; } */ inline int& MSurf_DLightBits( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_fDLightBits; } inline cplane_t& MSurf_Plane( SurfaceHandle_t surfID ) { #ifndef _PS3 return *surfID->plane; #else return surfID->m_plane; #endif } inline int& MSurf_FirstVertIndex( SurfaceHandle_t surfID ) { return surfID->firstvertindex; } inline int MSurf_VertCount( SurfaceHandle_t surfID ) { return (surfID->flags >> SURFDRAW_VERTCOUNT_SHIFT) & 0xFF; } inline void MSurf_SetVertCount( SurfaceHandle_t surfID, int vertCount ) { int flags = (vertCount << SURFDRAW_VERTCOUNT_SHIFT) & SURFDRAW_VERTCOUNT_MASK; surfID->flags |= flags; } inline int *MSurf_TextureMins( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfaces1[surfaceIndex].textureMins; } inline short *MSurf_TextureExtents( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfaces1[surfaceIndex].textureExtents; } inline short *MSurf_LightmapMins( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_LightmapMins; } inline short *MSurf_LightmapExtents( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_LightmapExtents; } inline short MSurf_MaxLightmapSizeWithBorder( SurfaceHandle_t surfID ) { // ASSERT_SURF_VALID( surfID ); return SurfaceHasDispInfo( surfID ) ? MAX_DISP_LIGHTMAP_DIM_INCLUDING_BORDER : MAX_BRUSH_LIGHTMAP_DIM_INCLUDING_BORDER; } inline short MSurf_MaxLightmapSizeWithoutBorder( SurfaceHandle_t surfID ) { // ASSERT_SURF_VALID( surfID ); return SurfaceHasDispInfo( surfID ) ? MAX_DISP_LIGHTMAP_DIM_WITHOUT_BORDER : MAX_BRUSH_LIGHTMAP_DIM_WITHOUT_BORDER; } inline mtexinfo_t *MSurf_TexInfo( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { return &pData->texinfo[surfID->texinfo]; } inline WorldDecalHandle_t& MSurf_Decals( SurfaceHandle_t surfID ) { return surfID->decals; } inline bool SurfaceHasDecals( SurfaceHandle_t surfID ) { return ( MSurf_Decals( surfID ) != WORLD_DECAL_HANDLE_INVALID ) ? true : false; } inline ShadowDecalHandle_t& MSurf_ShadowDecals( SurfaceHandle_t surfID ) { return surfID->m_ShadowDecals; } inline ColorRGBExp32 *MSurf_AvgLightColor( SurfaceHandle_t surfID, int nIndex, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].AvgLightColor(nIndex); } inline byte *MSurf_Styles( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_nStyles; } /* inline int *MSurf_CachedLight( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfID].cached_light; } inline short& MSurf_CachedDLight( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfID].cached_dlight; } */ inline unsigned short MSurf_NumPrims( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { if ( SurfaceHasDispInfo( surfID ) || !SurfaceHasPrims( surfID )) return 0; int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfaces1[surfaceIndex].prims.numPrims; } inline unsigned short MSurf_FirstPrimID( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { if ( SurfaceHasDispInfo( surfID ) ) return 0; int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfaces1[surfaceIndex].prims.firstPrimID; } inline ColorRGBExp32 *MSurf_Samples( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_pSamples; } inline IDispInfo *MSurf_DispInfo( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { return surfID->pDispInfo; } //inline unsigned short &MSurf_FirstVertNormal( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) inline unsigned int &MSurf_FirstVertNormal( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); Assert( pData->surfacenormals[surfaceIndex].firstvertnormal < MAX_MAP_VERTNORMALINDICES ); return pData->surfacenormals[surfaceIndex].firstvertnormal; } inline unsigned short &MSurf_VertBufferIndex( SurfaceHandle_t surfID ) { return surfID->vertBufferIndex; } inline short& MSurf_MaterialSortID( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { return surfID->materialSortID; } inline short *MSurf_OffsetIntoLightmapPage( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); // ASSERT_SURF_VALID( surfID ); Assert( pData ); return pData->surfacelighting[surfaceIndex].m_OffsetIntoLightmapPage; } inline VPlane MSurf_GetForwardFacingPlane( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { // ASSERT_SURF_VALID( surfID ); Assert( pData ); return VPlane( MSurf_Plane( surfID).normal, MSurf_Plane( surfID ).dist ); } inline OverlayFragmentHandle_t &MSurf_OverlayFragmentList( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { return surfID->m_nFirstOverlayFragment; } inline msurfacelighting_t *SurfaceLighting( SurfaceHandle_t surfID, worldbrushdata_t *pData = host_state.worldbrush ) { int surfaceIndex = MSurf_Index(surfID,pData); Assert( pData ); return &pData->surfacelighting[surfaceIndex]; } #endif // GL_MODEL_PRIVATE_H