797 lines
22 KiB
C++
797 lines
22 KiB
C++
//========= 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
|