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.
 
 
 
 
 
 

614 lines
19 KiB

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