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