d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
408 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: efbcaf7820
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'efbcaf7820'
${ noResults }
source-engine/engine/gl_model_private.h

796 lines
22 KiB
Raw Blame History

//========= 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