path: root/engine/gl_model_private.h

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