615 lines
19 KiB
C++
615 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// $Log: $
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef VRAD_H
|
|
#define VRAD_H
|
|
#pragma once
|
|
|
|
|
|
#include "commonmacros.h"
|
|
#include "worldsize.h"
|
|
#include "cmdlib.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "bsplib.h"
|
|
#include "polylib.h"
|
|
#include "threads.h"
|
|
#include "builddisp.h"
|
|
#include "VRAD_DispColl.h"
|
|
#include "UtlMemory.h"
|
|
#include "UtlHash.h"
|
|
#include "utlvector.h"
|
|
#include "iincremental.h"
|
|
#include "raytrace.h"
|
|
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#pragma warning(disable: 4142 4028)
|
|
#include <io.h>
|
|
#pragma warning(default: 4142 4028)
|
|
|
|
#include <fcntl.h>
|
|
#include <direct.h>
|
|
#include <ctype.h>
|
|
|
|
|
|
// Can remove these options if they don't generate problems.
|
|
//#define SAMPLEHASH_USE_AREA_PATCHES // Add patches to sample hash based on their AABB instead of as a single point.
|
|
#define SAMPLEHASH_QUERY_ONCE // Big optimization - causes way less sample hash queries.
|
|
|
|
extern float dispchop; // "-dispchop" tightest number of luxel widths for a patch, used on edges
|
|
extern float g_MaxDispPatchRadius;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct Ray_t;
|
|
|
|
#define TRANSFER_EPSILON 0.0000001
|
|
|
|
struct directlight_t
|
|
{
|
|
int index;
|
|
|
|
directlight_t *next;
|
|
dworldlight_t light;
|
|
|
|
byte *pvs; // accumulated domain of the light
|
|
int facenum; // domain of attached lights
|
|
int texdata; // texture source of traced lights
|
|
|
|
Vector snormal;
|
|
Vector tnormal;
|
|
float sscale;
|
|
float tscale;
|
|
float soffset;
|
|
float toffset;
|
|
|
|
int dorecalc; // position, vector, spot angle, etc.
|
|
IncrementalLightID m_IncrementalID;
|
|
|
|
// hard-falloff lights (lights that fade to an actual zero). between m_flStartFadeDistance and
|
|
// m_flEndFadeDistance, a smoothstep to zero will be done, so that the light goes to zero at
|
|
// the end.
|
|
float m_flStartFadeDistance;
|
|
float m_flEndFadeDistance;
|
|
float m_flCapDist; // max distance to feed in
|
|
|
|
directlight_t(void)
|
|
{
|
|
m_flEndFadeDistance = -1.0; // end<start indicates not set
|
|
m_flStartFadeDistance= 0.0;
|
|
m_flCapDist = 1.0e22;
|
|
|
|
}
|
|
};
|
|
|
|
struct bumplights_t
|
|
{
|
|
Vector light[NUM_BUMP_VECTS+1];
|
|
};
|
|
|
|
|
|
struct transfer_t
|
|
{
|
|
int patch;
|
|
float transfer;
|
|
};
|
|
|
|
|
|
struct LightingValue_t
|
|
{
|
|
Vector m_vecLighting;
|
|
float m_flDirectSunAmount;
|
|
|
|
FORCEINLINE bool IsValid( void ) const
|
|
{
|
|
return ( m_vecLighting.x >= 0 &&
|
|
m_vecLighting.y >= 0 &&
|
|
m_vecLighting.z >= 0 &&
|
|
m_vecLighting.x < 1e10 &&
|
|
m_vecLighting.y < 1e10 &&
|
|
m_vecLighting.z < 1e10 );
|
|
}
|
|
|
|
FORCEINLINE void Zero( void )
|
|
{
|
|
m_vecLighting.Init( 0, 0, 0 );
|
|
m_flDirectSunAmount = 0.0;
|
|
}
|
|
|
|
FORCEINLINE void Scale( float m_flScale )
|
|
{
|
|
m_vecLighting *= m_flScale;
|
|
m_flDirectSunAmount *= m_flScale;
|
|
}
|
|
|
|
FORCEINLINE void AddWeighted( LightingValue_t const &src, float flWeight )
|
|
{
|
|
m_vecLighting += flWeight * src.m_vecLighting;
|
|
m_flDirectSunAmount += flWeight * src.m_flDirectSunAmount;
|
|
}
|
|
|
|
FORCEINLINE void AddWeighted( Vector const &src, float flWeight )
|
|
{
|
|
m_vecLighting += flWeight * src;
|
|
}
|
|
|
|
FORCEINLINE float Intensity( void ) const
|
|
{
|
|
return m_vecLighting.x + m_vecLighting.y + m_vecLighting.z;
|
|
}
|
|
|
|
FORCEINLINE void AddLight( float flAmount, Vector const &vecColor, float flSunAmount = 0.0 )
|
|
{
|
|
VectorMA( m_vecLighting, flAmount, vecColor, m_vecLighting );
|
|
m_flDirectSunAmount += flSunAmount;
|
|
Assert( this->IsValid() );
|
|
}
|
|
|
|
|
|
FORCEINLINE void AddLight( LightingValue_t const &src )
|
|
{
|
|
m_vecLighting += src.m_vecLighting;
|
|
m_flDirectSunAmount += src.m_flDirectSunAmount;
|
|
Assert( this->IsValid() );
|
|
}
|
|
|
|
FORCEINLINE void Init( float x, float y, float z )
|
|
{
|
|
m_vecLighting.Init( x, y, z );
|
|
m_flDirectSunAmount = 0.0;
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
#define MAX_PATCHES (4*65536)
|
|
|
|
struct CPatch
|
|
{
|
|
winding_t *winding;
|
|
Vector mins, maxs, face_mins, face_maxs;
|
|
|
|
Vector origin; // adjusted off face by face normal
|
|
|
|
dplane_t *plane; // plane (corrected for facing)
|
|
|
|
unsigned short m_IterationKey; // Used to prevent touching the same patch multiple times in the same query.
|
|
// See IncrementPatchIterationKey().
|
|
|
|
// these are packed into one dword
|
|
unsigned int normalMajorAxis : 2; // the major axis of base face normal
|
|
unsigned int sky : 1;
|
|
unsigned int needsBumpmap : 1;
|
|
unsigned int pad : 28;
|
|
|
|
Vector normal; // adjusted for phong shading
|
|
|
|
float planeDist; // Fixes up patch planes for brush models with an origin brush
|
|
|
|
float chop; // smallest acceptable width of patch face
|
|
float luxscale; // average luxels per world coord
|
|
float scale[2]; // Scaling of texture in s & t
|
|
|
|
bumplights_t totallight; // accumulated by radiosity
|
|
// does NOT include light
|
|
// accounted for by direct lighting
|
|
Vector baselight; // emissivity only
|
|
float basearea; // surface per area per baselight instance
|
|
|
|
Vector directlight; // direct light value
|
|
float area;
|
|
|
|
Vector reflectivity; // Average RGB of texture, modified by material type.
|
|
|
|
Vector samplelight;
|
|
float samplearea; // for averaging direct light
|
|
int faceNumber;
|
|
int clusterNumber;
|
|
|
|
int parent; // patch index of parent
|
|
int child1; // patch index for children
|
|
int child2;
|
|
|
|
int ndxNext; // next patch index in face
|
|
int ndxNextParent; // next parent patch index in face
|
|
int ndxNextClusterChild; // next terminal child index in cluster
|
|
// struct patch_s *next; // next in face
|
|
// struct patch_s *nextparent; // next in face
|
|
// struct patch_s *nextclusterchild; // next terminal child in cluster
|
|
|
|
int numtransfers;
|
|
transfer_t *transfers;
|
|
|
|
short indices[3]; // displacement use these for subdivision
|
|
};
|
|
|
|
|
|
extern CUtlVector<CPatch> g_Patches;
|
|
extern CUtlVector<int> g_FacePatches; // constains all patches, children first
|
|
extern CUtlVector<int> faceParents; // contains only root patches, use next parent to iterate
|
|
extern CUtlVector<int> clusterChildren;
|
|
|
|
|
|
struct sky_camera_t
|
|
{
|
|
Vector origin;
|
|
float world_to_sky;
|
|
float sky_to_world;
|
|
int area;
|
|
};
|
|
|
|
extern int num_sky_cameras;
|
|
extern sky_camera_t sky_cameras[MAX_MAP_AREAS];
|
|
extern int area_sky_cameras[MAX_MAP_AREAS];
|
|
void ProcessSkyCameras();
|
|
|
|
extern entity_t *face_entity[MAX_MAP_FACES];
|
|
extern Vector face_offset[MAX_MAP_FACES]; // for rotating bmodels
|
|
extern Vector face_centroids[MAX_MAP_EDGES];
|
|
extern int leafparents[MAX_MAP_LEAFS];
|
|
extern int nodeparents[MAX_MAP_NODES];
|
|
extern float lightscale;
|
|
extern float dlight_threshold;
|
|
extern float coring;
|
|
extern qboolean g_bDumpPatches;
|
|
extern bool bRed2Black;
|
|
extern bool g_bNoSkyRecurse;
|
|
extern bool bDumpNormals;
|
|
extern bool g_bFastAmbient;
|
|
extern float maxchop;
|
|
extern FileHandle_t pFileSamples[4][4];
|
|
extern qboolean g_bLowPriority;
|
|
extern qboolean do_fast;
|
|
extern bool g_bInterrupt; // Was used with background lighting in WC. Tells VRAD to stop lighting.
|
|
extern IIncremental *g_pIncremental; // null if not doing incremental lighting
|
|
extern bool g_bDumpPropLightmaps;
|
|
|
|
extern float g_flSkySampleScale; // extra sampling factor for indirect light
|
|
|
|
extern bool g_bLargeDispSampleRadius;
|
|
extern bool g_bStaticPropPolys;
|
|
extern bool g_bTextureShadows;
|
|
extern bool g_bShowStaticPropNormals;
|
|
extern bool g_bDisablePropSelfShadowing;
|
|
|
|
extern CUtlVector<char const *> g_NonShadowCastingMaterialStrings;
|
|
extern void ForceTextureShadowsOnModel( const char *pModelName );
|
|
extern bool IsModelTextureShadowsForced( const char *pModelName );
|
|
|
|
// Raytracing
|
|
|
|
#define TRACE_ID_SKY 0x01000000 // sky face ray blocker
|
|
#define TRACE_ID_OPAQUE 0x02000000 // everyday light blocking face
|
|
#define TRACE_ID_STATICPROP 0x04000000 // static prop - lower bits are prop ID
|
|
extern RayTracingEnvironment g_RtEnv;
|
|
|
|
#include "mpivrad.h"
|
|
|
|
void MakeShadowSplits (void);
|
|
|
|
//==============================================
|
|
|
|
void BuildVisMatrix (void);
|
|
void BuildClusterTable( void );
|
|
void AddDispsToClusterTable( void );
|
|
void FreeVisMatrix (void);
|
|
// qboolean CheckVisBit (unsigned int p1, unsigned int p2);
|
|
void TouchVMFFile (void);
|
|
|
|
//==============================================
|
|
|
|
extern qboolean do_extra;
|
|
extern qboolean do_fast;
|
|
extern qboolean do_centersamples;
|
|
extern int extrapasses;
|
|
extern Vector ambient;
|
|
extern float maxlight;
|
|
extern unsigned numbounce;
|
|
extern qboolean g_bLogHashData;
|
|
extern bool debug_extra;
|
|
extern directlight_t *activelights;
|
|
extern directlight_t *freelights;
|
|
|
|
// because of hdr having two face lumps (light styles can cause them to be different, among other
|
|
// things), we need to always access (r/w) face data though this pointer
|
|
extern dface_t *g_pFaces;
|
|
|
|
|
|
extern bool g_bMPIProps;
|
|
|
|
extern byte nodehit[MAX_MAP_NODES];
|
|
extern float gamma;
|
|
extern float indirect_sun;
|
|
extern float smoothing_threshold;
|
|
extern int dlight_map;
|
|
|
|
extern float g_flMaxDispSampleSize;
|
|
extern float g_SunAngularExtent;
|
|
|
|
extern char source[MAX_PATH];
|
|
|
|
// Used by incremental lighting to trivial-reject faces.
|
|
// There is a bit in here for each face telling whether or not any of the
|
|
// active lights can see the face.
|
|
extern CUtlVector<byte> g_FacesVisibleToLights;
|
|
|
|
void MakeTnodes (dmodel_t *bm);
|
|
void PairEdges (void);
|
|
|
|
void SaveVertexNormals( void );
|
|
|
|
qboolean IsIncremental(char *filename);
|
|
int SaveIncremental(char *filename);
|
|
int PartialHead (void);
|
|
void BuildFacelights (int facenum, int threadnum);
|
|
void PrecompLightmapOffsets();
|
|
void FinalLightFace (int threadnum, int facenum);
|
|
void PvsForOrigin (Vector& org, byte *pvs);
|
|
void ConvertRGBExp32ToRGBA8888( const ColorRGBExp32 *pSrc, unsigned char *pDst, Vector* _optOutLinear = NULL );
|
|
void ConvertRGBExp32ToLinear(const ColorRGBExp32 *pSrc, Vector* pDst);
|
|
void ConvertLinearToRGBA8888( const Vector *pSrc, unsigned char *pDst );
|
|
|
|
|
|
inline byte PVSCheck( const byte *pvs, int iCluster )
|
|
{
|
|
if ( iCluster >= 0 )
|
|
{
|
|
return pvs[iCluster >> 3] & ( 1 << ( iCluster & 7 ) );
|
|
}
|
|
else
|
|
{
|
|
// PointInLeaf still returns -1 for valid points sometimes and rather than
|
|
// have black samples, we assume the sample is in the PVS.
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// outputs 1 in fractionVisible if no occlusion, 0 if full occlusion, and in-between values
|
|
void TestLine( FourVectors const& start, FourVectors const& stop, fltx4 *pFractionVisible, int static_prop_index_to_ignore=-1);
|
|
|
|
// returns 1 if the ray sees the sky, 0 if it doesn't, and in-between values for partial coverage
|
|
void TestLine_DoesHitSky( FourVectors const& start, FourVectors const& stop,
|
|
fltx4 *pFractionVisible, bool canRecurse = true, int static_prop_to_skip=-1, bool bDoDebug = false );
|
|
|
|
// converts any marked brush entities to triangles for shadow casting
|
|
void ExtractBrushEntityShadowCasters ( void );
|
|
void AddBrushesForRayTrace ( void );
|
|
|
|
void BaseLightForFace( dface_t *f, Vector& light, float *parea, Vector& reflectivity );
|
|
void CreateDirectLights (void);
|
|
void GetPhongNormal( int facenum, Vector const& spot, Vector& phongnormal );
|
|
int LightForString( char *pLight, Vector& intensity );
|
|
void MakeTransfer( int ndxPatch1, int ndxPatch2, transfer_t *all_transfers );
|
|
void MakeScales( int ndxPatch, transfer_t *all_transfers );
|
|
|
|
// Run startup code like initialize mathlib.
|
|
void VRAD_Init();
|
|
|
|
// Load the BSP file and prepare to do the lighting.
|
|
// This is called after any command-line parameters have been set.
|
|
void VRAD_LoadBSP( char const *pFilename );
|
|
|
|
int VRAD_Main(int argc, char **argv);
|
|
|
|
// This performs an actual lighting pass.
|
|
// Returns true if the process was interrupted (with g_bInterrupt).
|
|
bool RadWorld_Go();
|
|
|
|
dleaf_t *PointInLeaf (Vector const& point);
|
|
int ClusterFromPoint( Vector const& point );
|
|
winding_t *WindingFromFace (dface_t *f, Vector& origin );
|
|
|
|
void WriteWinding (FileHandle_t out, winding_t *w, Vector& color );
|
|
void WriteNormal( FileHandle_t out, Vector const &nPos, Vector const &nDir,
|
|
float length, Vector const &color );
|
|
void WriteLine( FileHandle_t out, const Vector &vecPos1, const Vector &vecPos2, const Vector &color );
|
|
void WriteTrace( const char *pFileName, const FourRays &rays, const RayTracingResult& result );
|
|
|
|
#ifdef STATIC_FOG
|
|
qboolean IsFog( dface_t * f );
|
|
#endif
|
|
|
|
#define CONTENTS_EMPTY 0
|
|
#define TEX_SPECIAL (SURF_SKY|SURF_NOLIGHT)
|
|
|
|
//=============================================================================
|
|
|
|
// trace.cpp
|
|
|
|
bool AddDispCollTreesToWorld( void );
|
|
int PointLeafnum( Vector const &point );
|
|
float TraceLeafBrushes( int leafIndex, const Vector &start, const Vector &end, CBaseTrace &traceOut );
|
|
|
|
//=============================================================================
|
|
|
|
// dispinfo.cpp
|
|
|
|
struct SSE_sampleLightOutput_t
|
|
{
|
|
fltx4 m_flDot[NUM_BUMP_VECTS+1];
|
|
fltx4 m_flFalloff;
|
|
fltx4 m_flSunAmount;
|
|
};
|
|
|
|
#define GATHERLFLAGS_FORCE_FAST 1
|
|
#define GATHERLFLAGS_IGNORE_NORMALS 2
|
|
|
|
// SSE Gather light stuff
|
|
void GatherSampleLightSSE( SSE_sampleLightOutput_t &out, directlight_t *dl, int facenum,
|
|
FourVectors const& pos, FourVectors *pNormals, int normalCount, int iThread,
|
|
int nLFlags = 0, // GATHERLFLAGS_xxx
|
|
int static_prop_to_skip=-1,
|
|
float flEpsilon = 0.0 );
|
|
//void GatherSampleSkyLightSSE( SSE_sampleLightOutput_t &out, directlight_t *dl, int facenum,
|
|
// FourVectors const& pos, FourVectors *pNormals, int normalCount, int iThread,
|
|
// int nLFlags = 0,
|
|
// int static_prop_to_skip=-1,
|
|
// float flEpsilon = 0.0 );
|
|
//void GatherSampleAmbientSkySSE( SSE_sampleLightOutput_t &out, directlight_t *dl, int facenum,
|
|
// FourVectors const& pos, FourVectors *pNormals, int normalCount, int iThread,
|
|
// int nLFlags = 0, // GATHERLFLAGS_xxx
|
|
// int static_prop_to_skip=-1,
|
|
// float flEpsilon = 0.0 );
|
|
//void GatherSampleStandardLightSSE( SSE_sampleLightOutput_t &out, directlight_t *dl, int facenum,
|
|
// FourVectors const& pos, FourVectors *pNormals, int normalCount, int iThread,
|
|
// int nLFlags = 0, // GATHERLFLAGS_xxx
|
|
// int static_prop_to_skip=-1,
|
|
// float flEpsilon = 0.0 );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// VRad Displacements
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct facelight_t;
|
|
typedef struct radial_s radial_t;
|
|
struct lightinfo_t;
|
|
|
|
// NOTE: should probably come up with a bsptreetested_t struct or something,
|
|
// see below (PropTested_t)
|
|
struct DispTested_t
|
|
{
|
|
int m_Enum;
|
|
int *m_pTested;
|
|
};
|
|
|
|
class IVRadDispMgr
|
|
{
|
|
public:
|
|
// creation/destruction
|
|
virtual void Init( void ) = 0;
|
|
virtual void Shutdown( void ) = 0;
|
|
|
|
// "CalcPoints"
|
|
virtual bool BuildDispSamples( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace ) = 0;
|
|
virtual bool BuildDispLuxels( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace ) = 0;
|
|
virtual bool BuildDispSamplesAndLuxels_DoFast( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace ) = 0;
|
|
|
|
// patching functions
|
|
virtual void MakePatches( void ) = 0;
|
|
virtual void SubdividePatch( int iPatch ) = 0;
|
|
|
|
// pre "FinalLightFace"
|
|
virtual void InsertSamplesDataIntoHashTable( void ) = 0;
|
|
virtual void InsertPatchSampleDataIntoHashTable( void ) = 0;
|
|
|
|
// "FinalLightFace"
|
|
virtual radial_t *BuildLuxelRadial( int ndxFace, int ndxStyle, bool bBump ) = 0;
|
|
virtual bool SampleRadial( int ndxFace, radial_t *pRadial, Vector const &vPos, int ndxLxl, LightingValue_t *pLightSample, int sampleCount, bool bPatch ) = 0;
|
|
virtual radial_t *BuildPatchRadial( int ndxFace, bool bBump ) = 0;
|
|
|
|
// utility
|
|
virtual void GetDispSurfNormal( int ndxFace, Vector &pt, Vector &ptNormal, bool bInside ) = 0;
|
|
virtual void GetDispSurf( int ndxFace, CVRADDispColl **ppDispTree ) = 0;
|
|
|
|
// bsp tree functions
|
|
virtual bool ClipRayToDisp( DispTested_t &dispTested, Ray_t const &ray ) = 0;
|
|
virtual bool ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray, int ndxLeaf ) = 0;
|
|
virtual void ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
|
|
int ndxLeaf, float& dist, dface_t*& pFace, Vector2D& luxelCoord ) = 0;
|
|
virtual void ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
|
|
int ndxLeaf, float& dist, Vector *pNormal ) = 0;
|
|
virtual void StartRayTest( DispTested_t &dispTested ) = 0;
|
|
virtual void AddPolysForRayTrace() = 0;
|
|
|
|
// general timing -- should be moved!!
|
|
virtual void StartTimer( const char *name ) = 0;
|
|
virtual void EndTimer( void ) = 0;
|
|
};
|
|
|
|
IVRadDispMgr *StaticDispMgr( void );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline bool ValidDispFace( dface_t *pFace )
|
|
{
|
|
if( !pFace ) { return false; }
|
|
if( pFace->dispinfo == -1 ) { return false; }
|
|
if( pFace->numedges != 4 ) { return false; }
|
|
|
|
return true;
|
|
}
|
|
|
|
#define SAMPLEHASH_VOXEL_SIZE 64.0f
|
|
typedef unsigned int SampleHandle_t; // the upper 16 bits = facelight index (works because max face are 65536)
|
|
// the lower 16 bits = sample index inside of facelight
|
|
struct sample_t;
|
|
struct SampleData_t
|
|
{
|
|
unsigned short x, y, z;
|
|
CUtlVector<SampleHandle_t> m_Samples;
|
|
};
|
|
|
|
struct PatchSampleData_t
|
|
{
|
|
unsigned short x, y, z;
|
|
CUtlVector<int> m_ndxPatches;
|
|
};
|
|
|
|
UtlHashHandle_t SampleData_AddSample( sample_t *pSample, SampleHandle_t sampleHandle );
|
|
void PatchSampleData_AddSample( CPatch *pPatch, int ndxPatch );
|
|
unsigned short IncrementPatchIterationKey();
|
|
void SampleData_Log( void );
|
|
|
|
extern CUtlHash<SampleData_t> g_SampleHashTable;
|
|
extern CUtlHash<PatchSampleData_t> g_PatchSampleHashTable;
|
|
|
|
extern int samplesAdded;
|
|
extern int patchSamplesAdded;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes lighting for the detail props
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ComputeDetailPropLighting( int iThread );
|
|
void ComputeIndirectLightingAtPoint( Vector &position, Vector &normal, Vector &outColor,
|
|
int iThread, bool force_fast = false, bool bIgnoreNormals = false );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// VRad static props
|
|
//-----------------------------------------------------------------------------
|
|
class IPhysicsCollision;
|
|
struct PropTested_t
|
|
{
|
|
int m_Enum;
|
|
int* m_pTested;
|
|
IPhysicsCollision *pThreadedCollision;
|
|
};
|
|
|
|
class IVradStaticPropMgr
|
|
{
|
|
public:
|
|
// methods of IStaticPropMgr
|
|
virtual void Init() = 0;
|
|
virtual void Shutdown() = 0;
|
|
virtual void ComputeLighting( int iThread ) = 0;
|
|
virtual void AddPolysForRayTrace() = 0;
|
|
};
|
|
|
|
//extern PropTested_t s_PropTested[MAX_TOOL_THREADS+1];
|
|
extern DispTested_t s_DispTested[MAX_TOOL_THREADS+1];
|
|
|
|
IVradStaticPropMgr* StaticPropMgr();
|
|
|
|
extern float ComputeCoverageFromTexture( float b0, float b1, float b2, int32 hitID );
|
|
|
|
#endif // VRAD_H
|