diff options
Diffstat (limited to 'engine/gl_model_private.h')
| -rw-r--r-- | engine/gl_model_private.h | 796 |
1 files changed, 796 insertions, 0 deletions
diff --git a/engine/gl_model_private.h b/engine/gl_model_private.h new file mode 100644 index 0000000..7b1f132 --- /dev/null +++ b/engine/gl_model_private.h @@ -0,0 +1,796 @@ +//========= Copyright 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" + + +//----------------------------------------------------------------------------- +// 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_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 + +struct worldbrushdata_t +{ + int numsubmodels; + + 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; + + bool unloadedlightmaps; + + int numvertindices; + unsigned short *vertindices; + + int nummarksurfaces; + SurfaceHandle_t *marksurfaces; + + ColorRGBExp32 *lightdata; + + 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; +#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, nummodelsurfaces; + + 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; + CUtlString strName; + + int nLoadFlags; // mark loaded/not loaded + int nServerCount; // marked at load + IMaterial **ppMaterials; // null-terminated runtime material cache; ((intptr_t*)(ppMaterials))[-1] == nMaterials + + modtype_t type; + int flags; // MODELFLAG_??? + + // volume occupied by the model graphics + Vector mins, maxs; + float radius; + + 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(index<pLeaf->dispCount); + 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 +#define SURFDRAW_DLIGHTPASS 0x00100000 // Must be drawn in the dlight pass +#define SURFDRAW_UNUSED2 0x00200000 // unused +#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; +}; + +#pragma pack(1) +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 +}; +#pragma pack() + +// 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; + +#pragma pack(1) +// 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? + cplane_t *plane; // pointer to shared plane + 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 +}; +#pragma pack() + +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 ) +{ + return *surfID->plane; +} + +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 |