d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
100 Commits
25 Branches
6 Tags
221 MiB
Branch: dedicated
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'dedicated'
${ noResults }
source-engine/utils/vrad/vraddisps.cpp

1760 lines
53 KiB
Raw Permalink Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "vrad.h"
#include "utlvector.h"
#include "cmodel.h"
#include "BSPTreeData.h"
#include "VRAD_DispColl.h"
#include "CollisionUtils.h"
#include "lightmap.h"
#include "Radial.h"
#include "CollisionUtils.h"
#include "mathlib/bumpvects.h"
#include "utlrbtree.h"
#include "tier0/fasttimer.h"
#include "disp_vrad.h"
class CBSPDispRayDistanceEnumerator;
//=============================================================================
//
// Displacement/Face List
//
class CBSPDispFaceListEnumerator : public ISpatialLeafEnumerator, public IBSPTreeDataEnumerator
{
public:
//=========================================================================
//
// Construction/Deconstruction
//
CBSPDispFaceListEnumerator() {};
virtual ~CBSPDispFaceListEnumerator()
{
m_DispList.Purge();
m_FaceList.Purge();
}
// ISpatialLeafEnumerator
bool EnumerateLeaf( int ndxLeaf, int context );
// IBSPTreeDataEnumerator
bool FASTCALL EnumerateElement( int userId, int context );
public:
CUtlVector<CVRADDispColl*> m_DispList;
CUtlVector<int> m_FaceList;
};
//=============================================================================
//
// RayEnumerator
//
class CBSPDispRayEnumerator : public ISpatialLeafEnumerator, public IBSPTreeDataEnumerator
{
public:
// ISpatialLeafEnumerator
bool EnumerateLeaf( int ndxLeaf, int context );
// IBSPTreeDataEnumerator
bool FASTCALL EnumerateElement( int userId, int context );
};
//=============================================================================
//
// VRad Displacement Manager
//
class CVRadDispMgr : public IVRadDispMgr
{
public:
//=========================================================================
//
// Construction/Deconstruction
//
CVRadDispMgr();
virtual ~CVRadDispMgr();
// creation/destruction
void Init( void );
void Shutdown( void );
// "CalcPoints"
bool BuildDispSamples( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace );
bool BuildDispLuxels( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace );
bool BuildDispSamplesAndLuxels_DoFast( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace );
// patching functions
void MakePatches( void );
void SubdividePatch( int iPatch );
// pre "FinalLightFace"
void InsertSamplesDataIntoHashTable( void );
void InsertPatchSampleDataIntoHashTable( void );
// "FinalLightFace"
radial_t *BuildLuxelRadial( int ndxFace, int ndxStyle, bool bBump );
bool SampleRadial( int ndxFace, radial_t *pRadial, Vector const &vPos, int ndxLxl, LightingValue_t *pLightSample, int sampleCount, bool bPatch );
radial_t *BuildPatchRadial( int ndxFace, bool bBump );
// utility
void GetDispSurfNormal( int ndxFace, Vector &pt, Vector &ptNormal, bool bInside );
void GetDispSurf( int ndxFace, CVRADDispColl **ppDispTree );
// bsp tree functions
bool ClipRayToDisp( DispTested_t &dispTested, Ray_t const &ray );
bool ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray, int ndxLeaf );
void ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray, int ndxLeaf,
float& dist, dface_t*& pFace, Vector2D& luxelCoord );
void ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
int ndxLeaf, float& dist, Vector *pNormal );
void StartRayTest( DispTested_t &dispTested );
void AddPolysForRayTrace( void );
// general timing -- should be moved!!
void StartTimer( const char *name );
void EndTimer( void );
//=========================================================================
//
// Enumeration Methods
//
bool DispRay_EnumerateLeaf( int ndxLeaf, int context );
bool DispRay_EnumerateElement( int userId, int context );
bool DispRayDistance_EnumerateElement( int userId, CBSPDispRayDistanceEnumerator* pEnum );
bool DispFaceList_EnumerateLeaf( int ndxLeaf, int context );
bool DispFaceList_EnumerateElement( int userId, int context );
private:
//=========================================================================
//
// BSP Tree Helpers
//
void InsertDispIntoTree( int ndxDisp );
void RemoveDispFromTree( int ndxDisp );
//=========================================================================
//
// Displacement Data Loader (from .bsp)
//
void UnserializeDisps( void );
void DispBuilderInit( CCoreDispInfo *pBuilderDisp, dface_t *pFace, int ndxFace );
//=========================================================================
//
// Sampling Helpers
//
void RadialLuxelBuild( CVRADDispColl *pDispTree, radial_t *pRadial, int ndxStyle, bool bBump );
void RadialLuxelAddSamples( int ndxFace, Vector const &luxelPt, Vector const &luxelNormal, float radius,
radial_t *pRadial, int ndxRadial, bool bBump, int lightStyle );
void RadialPatchBuild( CVRADDispColl *pDispTree, radial_t *pRadial, bool bBump );
void RadialLuxelAddPatch( int ndxFace, Vector const &luxelPt,
Vector const &luxelNormal, float radius,
radial_t *pRadial, int ndxRadial, bool bBump,
CUtlVector<CPatch*> &interestingPatches );
bool IsNeighbor( int iDispFace, int iNeighborFace );
void GetInterestingPatchesForLuxels(
int ndxFace,
CUtlVector<CPatch*> &interestingPatches,
float patchSampleRadius );
private:
struct DispCollTree_t
{
CVRADDispColl *m_pDispTree;
BSPTreeDataHandle_t m_Handle;
};
struct EnumContext_t
{
DispTested_t *m_pDispTested;
Ray_t const *m_pRay;
};
CUtlVector<DispCollTree_t> m_DispTrees;
IBSPTreeData *m_pBSPTreeData;
CBSPDispRayEnumerator m_EnumDispRay;
CBSPDispFaceListEnumerator m_EnumDispFaceList;
int sampleCount;
Vector *m_pSamplePos;
CFastTimer m_Timer;
};
//-----------------------------------------------------------------------------
// Purpose: expose IVRadDispMgr to vrad
//-----------------------------------------------------------------------------
static CVRadDispMgr s_DispMgr;
IVRadDispMgr *StaticDispMgr( void )
{
return &s_DispMgr;
}
//=============================================================================
//
// Displacement/Face List
//
// ISpatialLeafEnumerator
bool CBSPDispFaceListEnumerator::EnumerateLeaf( int ndxLeaf, int context )
{
return s_DispMgr.DispFaceList_EnumerateLeaf( ndxLeaf, context );
}
// IBSPTreeDataEnumerator
bool FASTCALL CBSPDispFaceListEnumerator::EnumerateElement( int userId, int context )
{
return s_DispMgr.DispFaceList_EnumerateElement( userId, context );
}
//=============================================================================
//
// RayEnumerator
//
bool CBSPDispRayEnumerator::EnumerateLeaf( int ndxLeaf, int context )
{
return s_DispMgr.DispRay_EnumerateLeaf( ndxLeaf, context );
}
bool FASTCALL CBSPDispRayEnumerator::EnumerateElement( int userId, int context )
{
return s_DispMgr.DispRay_EnumerateElement( userId, context );
}
//-----------------------------------------------------------------------------
// Here's an enumerator that we use for testing against disps in a leaf...
//-----------------------------------------------------------------------------
class CBSPDispRayDistanceEnumerator : public IBSPTreeDataEnumerator
{
public:
CBSPDispRayDistanceEnumerator() : m_Distance(1.0f), m_pSurface(0) {}
// IBSPTreeDataEnumerator
bool FASTCALL EnumerateElement( int userId, int context )
{
return s_DispMgr.DispRayDistance_EnumerateElement( userId, this );
}
float m_Distance;
dface_t* m_pSurface;
DispTested_t *m_pDispTested;
Ray_t const *m_pRay;
Vector2D m_LuxelCoord;
Vector m_Normal;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CVRadDispMgr::CVRadDispMgr()
{
m_pBSPTreeData = CreateBSPTreeData();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CVRadDispMgr::~CVRadDispMgr()
{
DestroyBSPTreeData( m_pBSPTreeData );
}
//-----------------------------------------------------------------------------
// Insert a displacement into the tree for collision
//-----------------------------------------------------------------------------
void CVRadDispMgr::InsertDispIntoTree( int ndxDisp )
{
DispCollTree_t &dispTree = m_DispTrees[ndxDisp];
CDispCollTree *pDispTree = dispTree.m_pDispTree;
// get the bounding box of the tree
Vector boxMin, boxMax;
pDispTree->GetBounds( boxMin, boxMax );
// add the displacement to the tree so we will collide against it
dispTree.m_Handle = m_pBSPTreeData->Insert( ndxDisp, boxMin, boxMax );
}
//-----------------------------------------------------------------------------
// Remove a displacement from the tree for collision
//-----------------------------------------------------------------------------
void CVRadDispMgr::RemoveDispFromTree( int ndxDisp )
{
// release the tree handle
if( m_DispTrees[ndxDisp].m_Handle != TREEDATA_INVALID_HANDLE )
{
m_pBSPTreeData->Remove( m_DispTrees[ndxDisp].m_Handle );
m_DispTrees[ndxDisp].m_Handle = TREEDATA_INVALID_HANDLE;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::Init( void )
{
// initialize the bsp tree
m_pBSPTreeData->Init( ToolBSPTree() );
// read in displacements that have been compiled into the bsp file
UnserializeDisps();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::Shutdown( void )
{
// remove all displacements from the tree
for( int ndxDisp = m_DispTrees.Size(); ndxDisp >= 0; ndxDisp-- )
{
RemoveDispFromTree( ndxDisp );
}
// shutdown the bsp tree
m_pBSPTreeData->Shutdown();
// purge the displacement collision tree list
m_DispTrees.Purge();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::DispBuilderInit( CCoreDispInfo *pBuilderDisp, dface_t *pFace, int ndxFace )
{
// get the .bsp displacement
ddispinfo_t *pDisp = &g_dispinfo[pFace->dispinfo];
if( !pDisp )
return;
//
// initlialize the displacement base surface
//
CCoreDispSurface *pSurf = pBuilderDisp->GetSurface();
pSurf->SetPointCount( 4 );
pSurf->SetHandle( ndxFace );
pSurf->SetContents( pDisp->contents );
Vector pt[4];
int ndxPt;
for( ndxPt = 0; ndxPt < 4; ndxPt++ )
{
int eIndex = dsurfedges[pFace->firstedge+ndxPt];
if( eIndex < 0 )
{
pSurf->SetPoint( ndxPt, dvertexes[dedges[-eIndex].v[1]].point );
}
else
{
pSurf->SetPoint( ndxPt, dvertexes[dedges[eIndex].v[0]].point );
}
VectorCopy( pSurf->GetPoint(ndxPt), pt[ndxPt] );
}
//
// calculate the displacement surface normal
//
Vector vFaceNormal;
pSurf->GetNormal( vFaceNormal );
for( ndxPt = 0; ndxPt < 4; ndxPt++ )
{
pSurf->SetPointNormal( ndxPt, vFaceNormal );
}
// set the surface initial point info
pSurf->SetPointStart( pDisp->startPosition );
pSurf->FindSurfPointStartIndex();
pSurf->AdjustSurfPointData();
Vector vecTmp( texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][0],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][1],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][2] );
int nLuxelsPerWorldUnit = static_cast<int>( 1.0f / VectorLength( vecTmp ) );
Vector vecU( texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][0],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][1],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[0][2] );
Vector vecV( texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[1][0],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[1][1],
texinfo[pFace->texinfo].lightmapVecsLuxelsPerWorldUnits[1][2] );
pSurf->CalcLuxelCoords( nLuxelsPerWorldUnit, false, vecU, vecV );
pBuilderDisp->SetNeighborData( pDisp->m_EdgeNeighbors, pDisp->m_CornerNeighbors );
CDispVert *pVerts = &g_DispVerts[ pDisp->m_iDispVertStart ];
CDispTri *pTris = &g_DispTris[pDisp->m_iDispTriStart];
//
// initialize the displacement data
//
pBuilderDisp->InitDispInfo(
pDisp->power,
pDisp->minTess,
pDisp->smoothingAngle,
pVerts,
pTris );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::UnserializeDisps( void )
{
// temporarily create the "builder" displacements
CUtlVector<CCoreDispInfo*> builderDisps;
for ( int iDisp = 0; iDisp < g_dispinfo.Count(); ++iDisp )
{
CCoreDispInfo *pDisp = new CCoreDispInfo;
if ( !pDisp )
{
builderDisps.Purge();
return;
}
int nIndex = builderDisps.AddToTail();
pDisp->SetListIndex( nIndex );
builderDisps[nIndex] = pDisp;
}
// Set them up as CDispUtilsHelpers.
for ( int iDisp = 0; iDisp < g_dispinfo.Count(); ++iDisp )
{
builderDisps[iDisp]->SetDispUtilsHelperInfo( builderDisps.Base(), g_dispinfo.Count() );
}
//
// find all faces with displacement data and initialize
//
for( int ndxFace = 0; ndxFace < numfaces; ndxFace++ )
{
dface_t *pFace = &g_pFaces[ndxFace];
if( ValidDispFace( pFace ) )
{
DispBuilderInit( builderDisps[pFace->dispinfo], pFace, ndxFace );
}
}
// generate the displacement surfaces
for( int iDisp = 0; iDisp < g_dispinfo.Count(); ++iDisp )
{
builderDisps[iDisp]->Create();
}
// smooth edge normals
SmoothNeighboringDispSurfNormals( builderDisps.Base(), g_dispinfo.Count() );
//
// create the displacement collision tree and add it to the bsp tree
//
CVRADDispColl *pDispTrees = new CVRADDispColl[g_dispinfo.Count()];
if( !pDispTrees )
return;
m_DispTrees.AddMultipleToTail( g_dispinfo.Count() );
for( int iDisp = 0; iDisp < g_dispinfo.Count(); iDisp++ )
{
pDispTrees[iDisp].Create( builderDisps[iDisp] );
m_DispTrees[iDisp].m_pDispTree = &pDispTrees[iDisp];
m_DispTrees[iDisp].m_Handle = TREEDATA_INVALID_HANDLE;
InsertDispIntoTree( iDisp );
}
// free "builder" disps
builderDisps.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: create a set of patches for each displacement surface to transfer
// bounced light around with
//-----------------------------------------------------------------------------
void CVRadDispMgr::MakePatches( void )
{
// Collect stats - keep track of the total displacement surface area.
float flTotalArea = 0.0f;
// Create patches for all of the displacements.
int nTreeCount = m_DispTrees.Size();
for( int iTree = 0; iTree < nTreeCount; ++iTree )
{
// Get the current displacement collision tree.
CVRADDispColl *pDispTree = m_DispTrees[iTree].m_pDispTree;
if( !pDispTree )
continue;
flTotalArea += pDispTree->CreateParentPatches();
}
// Print stats.
qprintf( "%i Displacements\n", nTreeCount );
qprintf( "%i Square Feet [%.2f Square Inches]\n", ( int )( flTotalArea / 144.0f ), flTotalArea );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::SubdividePatch( int iPatch )
{
// Get the current patch to subdivide.
CPatch *pPatch = &g_Patches[iPatch];
if ( !pPatch )
return;
// Create children patches.
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[pPatch->faceNumber].dispinfo];
CVRADDispColl *pTree = dispTree.m_pDispTree;
if( pTree )
{
pTree->CreateChildPatches( iPatch, 0 );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::StartRayTest( DispTested_t &dispTested )
{
if( m_DispTrees.Size() > 0 )
{
if( dispTested.m_pTested == 0 )
{
dispTested.m_pTested = new int[m_DispTrees.Size()];
memset( dispTested.m_pTested, 0, m_DispTrees.Size() * sizeof( int ) );
dispTested.m_Enum = 0;
}
++dispTested.m_Enum;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::ClipRayToDisp( DispTested_t &dispTested, Ray_t const &ray )
{
StartRayTest( dispTested );
EnumContext_t ctx;
ctx.m_pRay = &ray;
ctx.m_pDispTested = &dispTested;
// If it got through without a hit, it returns true
return !m_pBSPTreeData->EnumerateLeavesAlongRay( ray, &m_EnumDispRay, ( int )&ctx );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
int ndxLeaf )
{
EnumContext_t ctx;
ctx.m_pRay = &ray;
ctx.m_pDispTested = &dispTested;
return !m_pBSPTreeData->EnumerateElementsInLeaf( ndxLeaf, &m_EnumDispRay, ( int )&ctx );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
int ndxLeaf, float& dist, dface_t*& pFace, Vector2D& luxelCoord )
{
CBSPDispRayDistanceEnumerator rayTestEnum;
rayTestEnum.m_pRay = &ray;
rayTestEnum.m_pDispTested = &dispTested;
m_pBSPTreeData->EnumerateElementsInLeaf( ndxLeaf, &rayTestEnum, 0 );
dist = rayTestEnum.m_Distance;
pFace = rayTestEnum.m_pSurface;
if (pFace)
{
Vector2DCopy( rayTestEnum.m_LuxelCoord, luxelCoord );
}
}
void CVRadDispMgr::ClipRayToDispInLeaf( DispTested_t &dispTested, Ray_t const &ray,
int ndxLeaf, float& dist, Vector *pNormal )
{
CBSPDispRayDistanceEnumerator rayTestEnum;
rayTestEnum.m_pRay = &ray;
rayTestEnum.m_pDispTested = &dispTested;
m_pBSPTreeData->EnumerateElementsInLeaf( ndxLeaf, &rayTestEnum, 0 );
dist = rayTestEnum.m_Distance;
if ( rayTestEnum.m_pSurface )
{
*pNormal = rayTestEnum.m_Normal;
}
}
void CVRadDispMgr::AddPolysForRayTrace( void )
{
int nTreeCount = m_DispTrees.Size();
for( int iTree = 0; iTree < nTreeCount; ++iTree )
{
// Get the current displacement collision tree.
CVRADDispColl *pDispTree = m_DispTrees[iTree].m_pDispTree;
// Add the triangles of the tree to the RT environment
pDispTree->AddPolysForRayTrace();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::GetDispSurfNormal( int ndxFace, Vector &pt, Vector &ptNormal,
bool bInside )
{
// get the displacement surface data
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
// find the parameterized displacement indices
Vector2D uv;
pDispTree->BaseFacePlaneToDispUV( pt, uv );
if( bInside )
{
if( uv[0] < 0.0f || uv[0] > 1.0f ) { Msg( "Disp UV (%f) outside bounds!\n", uv[0] ); }
if( uv[1] < 0.0f || uv[1] > 1.0f ) { Msg( "Disp UV (%f) outside bounds!\n", uv[1] ); }
}
if( uv[0] < 0.0f ) { uv[0] = 0.0f; }
if( uv[0] > 1.0f ) { uv[0] = 1.0f; }
if( uv[1] < 0.0f ) { uv[1] = 0.0f; }
if( uv[1] > 1.0f ) { uv[1] = 1.0f; }
// get the normal at "pt"
pDispTree->DispUVToSurfNormal( uv, ptNormal );
// get the new "pt"
pDispTree->DispUVToSurfPoint( uv, pt, 1.0f );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::GetDispSurf( int ndxFace, CVRADDispColl **ppDispTree )
{
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
*ppDispTree = dispTree.m_pDispTree;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::DispRay_EnumerateLeaf( int ndxLeaf, int context )
{
return m_pBSPTreeData->EnumerateElementsInLeaf( ndxLeaf, &m_EnumDispRay, context );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::DispRay_EnumerateElement( int userId, int context )
{
DispCollTree_t &dispTree = m_DispTrees[userId];
EnumContext_t *pCtx = ( EnumContext_t* )context;
// don't test twice (check tested value)
if( pCtx->m_pDispTested->m_pTested[userId] == pCtx->m_pDispTested->m_Enum )
return true;
// set the tested value
pCtx->m_pDispTested->m_pTested[userId] = pCtx->m_pDispTested->m_Enum;
// false mean stop iterating -- return false if we hit! (NOTE: opposite return
// result of the collision tree's ray test, thus the !)
CBaseTrace trace;
trace.fraction = 1.0f;
return ( !dispTree.m_pDispTree->AABBTree_Ray( *pCtx->m_pRay, pCtx->m_pRay->InvDelta(), &trace, true ) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::DispRayDistance_EnumerateElement( int userId, CBSPDispRayDistanceEnumerator* pCtx )
{
DispCollTree_t &dispTree = m_DispTrees[userId];
// don't test twice (check tested value)
if( pCtx->m_pDispTested->m_pTested[userId] == pCtx->m_pDispTested->m_Enum )
return true;
// set the tested value
pCtx->m_pDispTested->m_pTested[userId] = pCtx->m_pDispTested->m_Enum;
// Test the ray, if it's closer than previous tests, use it!
RayDispOutput_t output;
output.ndxVerts[0] = -1;
output.ndxVerts[1] = -1;
output.ndxVerts[2] = -1;
output.ndxVerts[3] = -1;
output.u = -1.0f;
output.v = -1.0f;
output.dist = FLT_MAX;
if (dispTree.m_pDispTree->AABBTree_Ray( *pCtx->m_pRay, output ))
{
if (output.dist < pCtx->m_Distance)
{
pCtx->m_Distance = output.dist;
pCtx->m_pSurface = &g_pFaces[dispTree.m_pDispTree->GetParentIndex()];
// Get the luxel coordinate
ComputePointFromBarycentric(
dispTree.m_pDispTree->GetLuxelCoord(output.ndxVerts[0]),
dispTree.m_pDispTree->GetLuxelCoord(output.ndxVerts[1]),
dispTree.m_pDispTree->GetLuxelCoord(output.ndxVerts[2]),
output.u, output.v, pCtx->m_LuxelCoord );
Vector v0,v1,v2;
dispTree.m_pDispTree->GetVert( output.ndxVerts[0], v0 );
dispTree.m_pDispTree->GetVert( output.ndxVerts[1], v1 );
dispTree.m_pDispTree->GetVert( output.ndxVerts[2], v2 );
Vector e0 = v1-v0;
Vector e1 = v2-v0;
pCtx->m_Normal = CrossProduct( e0, e1 );
VectorNormalize(pCtx->m_Normal);
}
}
return true;
}
//-----------------------------------------------------------------------------
// Test a ray against a particular dispinfo
//-----------------------------------------------------------------------------
/*
float CVRadDispMgr::ClipRayToDisp( Ray_t const &ray, int dispinfo )
{
assert( m_DispTrees.IsValidIndex(dispinfo) );
RayDispOutput_t output;
if (!m_DispTrees[dispinfo].m_pDispTree->AABBTree_Ray( ray, output ))
return 1.0f;
return output.dist;
}
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::DispFaceList_EnumerateLeaf( int ndxLeaf, int context )
{
//
// add the faces found in this leaf to the face list
//
dleaf_t *pLeaf = &dleafs[ndxLeaf];
for( int ndxFace = 0; ndxFace < pLeaf->numleaffaces; ndxFace++ )
{
// get the current face index
int ndxLeafFace = pLeaf->firstleafface + ndxFace;
// check to see if the face already lives in the list
int ndx;
int size = m_EnumDispFaceList.m_FaceList.Size();
for( ndx = 0; ndx < size; ndx++ )
{
if( m_EnumDispFaceList.m_FaceList[ndx] == ndxLeafFace )
break;
}
if( ndx == size )
{
int ndxList = m_EnumDispFaceList.m_FaceList.AddToTail();
m_EnumDispFaceList.m_FaceList[ndxList] = ndxLeafFace;
}
}
return m_pBSPTreeData->EnumerateElementsInLeaf( ndxLeaf, &m_EnumDispFaceList, context );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::DispFaceList_EnumerateElement( int userId, int context )
{
DispCollTree_t &dispTree = m_DispTrees[userId];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return false;
// check to see if the displacement already lives in the list
int ndx;
int size = m_EnumDispFaceList.m_DispList.Size();
for( ndx = 0; ndx < size; ndx++ )
{
if( m_EnumDispFaceList.m_DispList[ndx] == pDispTree )
break;
}
if( ndx == size )
{
int ndxList = m_EnumDispFaceList.m_DispList.AddToTail();
m_EnumDispFaceList.m_DispList[ndxList] = pDispTree;
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void GetSampleLight( facelight_t *pFaceLight, int ndxStyle, bool bBumped,
int ndxSample, LightingValue_t *pSampleLight )
{
// SampleLight[0].Init( 20.0f, 10.0f, 10.0f );
// return;
// get sample from bumped lighting data
if( bBumped )
{
for( int ndxBump = 0; ndxBump < ( NUM_BUMP_VECTS+1 ); ndxBump++ )
{
pSampleLight[ndxBump] = pFaceLight->light[ndxStyle][ndxBump][ndxSample];
}
}
// just a generally lit surface
else
{
pSampleLight[0] = pFaceLight->light[ndxStyle][0][ndxSample];
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void AddSampleLightToRadial( Vector const &samplePos, Vector const &sampleNormal,
LightingValue_t *pSampleLight, float sampleRadius2,
Vector const &luxelPos, Vector const &luxelNormal,
radial_t *pRadial, int ndxRadial, bool bBumped,
bool bNeighborBumped )
{
// check normals to see if sample contributes any light at all
float angle = sampleNormal.Dot( luxelNormal );
if ( angle < 0.15f )
return;
// calculate the light vector
Vector vSegment = samplePos - luxelPos;
// get the distance to the light
float dist = vSegment.Length();
float dist2 = dist * dist;
// Check to see if the light is within the influence.
float influence = 1.0f - ( dist2 / ( sampleRadius2 ) );
if( influence <= 0.0f )
return;
influence *= angle;
if( bBumped )
{
if( bNeighborBumped )
{
for( int ndxBump = 0; ndxBump < ( NUM_BUMP_VECTS+1 ); ndxBump++ )
{
pRadial->light[ndxBump][ndxRadial].AddWeighted( pSampleLight[ndxBump], influence );
}
pRadial->weight[ndxRadial] += influence;
}
else
{
influence *= 0.05f;
for( int ndxBump = 0; ndxBump < ( NUM_BUMP_VECTS+1 ); ndxBump++ )
{
pRadial->light[ndxBump][ndxRadial].AddWeighted( pSampleLight[0], influence );
}
pRadial->weight[ndxRadial] += influence;
}
}
else
{
pRadial->light[0][ndxRadial].AddWeighted( pSampleLight[0], influence );
pRadial->weight[ndxRadial] += influence;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::IsNeighbor( int iFace, int iNeighborFace )
{
if ( iFace == iNeighborFace )
return true;
faceneighbor_t *pFaceNeighbor = &faceneighbor[iFace];
for ( int iNeighbor = 0; iNeighbor < pFaceNeighbor->numneighbors; iNeighbor++ )
{
if ( pFaceNeighbor->neighbor[iNeighbor] == iNeighborFace )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::RadialLuxelAddSamples( int ndxFace, Vector const &luxelPt, Vector const &luxelNormal, float radius,
radial_t *pRadial, int ndxRadial, bool bBump, int lightStyle )
{
// calculate one over the voxel size
float ooVoxelSize = 1.0f / SAMPLEHASH_VOXEL_SIZE;
//
// find voxel info
//
int voxelMin[3], voxelMax[3];
for( int axis = 0; axis < 3; axis++ )
{
voxelMin[axis] = ( int )( ( luxelPt[axis] - radius ) * ooVoxelSize );
voxelMax[axis] = ( int )( ( luxelPt[axis] + radius ) * ooVoxelSize ) + 1;
}
SampleData_t sampleData;
for( int ndxZ = voxelMin[2]; ndxZ < voxelMax[2] + 1; ndxZ++ )
{
for( int ndxY = voxelMin[1]; ndxY < voxelMax[1] + 1; ndxY++ )
{
for( int ndxX = voxelMin[0]; ndxX < voxelMax[0] + 1; ndxX++ )
{
sampleData.x = ndxX * 100;
sampleData.y = ndxY * 10;
sampleData.z = ndxZ;
UtlHashHandle_t handle = g_SampleHashTable.Find( sampleData );
if( handle != g_SampleHashTable.InvalidHandle() )
{
SampleData_t *pSampleData = &g_SampleHashTable.Element( handle );
int count = pSampleData->m_Samples.Count();
for( int ndx = 0; ndx < count; ndx++ )
{
SampleHandle_t sampleHandle = pSampleData->m_Samples.Element( ndx );
int ndxSample = ( sampleHandle & 0x0000ffff );
int ndxFaceLight = ( ( sampleHandle >> 16 ) & 0x0000ffff );
facelight_t *pFaceLight = &facelight[ndxFaceLight];
if( pFaceLight && IsNeighbor( ndxFace, ndxFaceLight ) )
{
//
// check for similar lightstyles
//
dface_t *pFace = &g_pFaces[ndxFaceLight];
if( pFace )
{
int ndxNeighborStyle = -1;
for( int ndxLightStyle = 0; ndxLightStyle < MAXLIGHTMAPS; ndxLightStyle++ )
{
if( pFace->styles[ndxLightStyle] == lightStyle )
{
ndxNeighborStyle = ndxLightStyle;
break;
}
}
if( ndxNeighborStyle == -1 )
continue;
// is this surface bumped???
bool bNeighborBump = texinfo[pFace->texinfo].flags & SURF_BUMPLIGHT ? true : false;
LightingValue_t sampleLight[NUM_BUMP_VECTS+1];
GetSampleLight( pFaceLight, ndxNeighborStyle, bNeighborBump, ndxSample, sampleLight );
AddSampleLightToRadial( pFaceLight->sample[ndxSample].pos, pFaceLight->sample[ndxSample].normal,
sampleLight, radius*radius, luxelPt, luxelNormal, pRadial, ndxRadial,
bBump, bNeighborBump );
}
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::RadialLuxelBuild( CVRADDispColl *pDispTree, radial_t *pRadial,
int ndxStyle, bool bBump )
{
//
// get data lighting data
//
int ndxFace = pDispTree->GetParentIndex();
dface_t *pFace = &g_pFaces[ndxFace];
facelight_t *pFaceLight = &facelight[ndxFace];
// get the influence radius
float radius2 = pDispTree->GetSampleRadius2();
float radius = ( float )sqrt( radius2 );
int radialSize = pRadial->w * pRadial->h;
for( int ndxRadial = 0; ndxRadial < radialSize; ndxRadial++ )
{
RadialLuxelAddSamples( ndxFace, pFaceLight->luxel[ndxRadial], pFaceLight->luxelNormals[ndxRadial],
radius, pRadial, ndxRadial, bBump, pFace->styles[ndxStyle] );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
radial_t *CVRadDispMgr::BuildLuxelRadial( int ndxFace, int ndxStyle, bool bBump )
{
// allocate the radial
radial_t *pRadial = AllocateRadial( ndxFace );
if( !pRadial )
return NULL;
//
// step 1: get the displacement surface to be lit
//
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return NULL;
// step 2: build radial luxels
RadialLuxelBuild( pDispTree, pRadial, ndxStyle, bBump );
// step 3: return the built radial
return pRadial;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::SampleRadial( int ndxFace, radial_t *pRadial, Vector const &vPos, int ndxLxl,
LightingValue_t *pLightSample, int sampleCount, bool bPatch )
{
bool bGoodSample = true;
for ( int count = 0; count < sampleCount; count++ )
{
pLightSample[count].Zero();
if ( pRadial->weight[ndxLxl] > 0.0f )
{
pLightSample[count].AddWeighted( pRadial->light[count][ndxLxl], ( 1.0f / pRadial->weight[ndxLxl] ) );
}
else
{
// error, luxel has no samples (not for patches)
if ( !bPatch )
{
// Yes, 2550 is correct!
// pLightSample[count].Init( 2550.0f, 0.0f, 2550.0f );
if( count == 0 )
bGoodSample = false;
}
}
}
return bGoodSample;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void GetPatchLight( CPatch *pPatch, bool bBump, Vector *pPatchLight )
{
VectorCopy( pPatch->totallight.light[0], pPatchLight[0] );
if( bBump )
{
for( int ndxBump = 1; ndxBump < ( NUM_BUMP_VECTS + 1 ); ndxBump++ )
{
VectorCopy( pPatch->totallight.light[ndxBump], pPatchLight[ndxBump] );
}
}
}
extern void GetBumpNormals( const float* sVect, const float* tVect, const Vector& flatNormal,
const Vector& phongNormal, Vector bumpNormals[NUM_BUMP_VECTS] );
extern void PreGetBumpNormalsForDisp( texinfo_t *pTexinfo, Vector &vecU, Vector &vecV, Vector &vecNormal );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void AddPatchLightToRadial( Vector const &patchOrigin, Vector const &patchNormal,
Vector *pPatchLight, float patchRadius2,
Vector const &luxelPos, Vector const &luxelNormal,
radial_t *pRadial, int ndxRadial, bool bBump,
bool bNeighborBump )
{
// calculate the light vector
Vector vSegment = patchOrigin - luxelPos;
// get the distance to the light
float dist = vSegment.Length();
float dist2 = dist * dist;
// Check to see if the light is within the sample influence.
float influence = 1.0f - ( dist2 / ( patchRadius2 ) );
if ( influence <= 0.0f )
return;
if( bBump )
{
Vector normals[NUM_BUMP_VECTS+1];
normals[0] = luxelNormal;
texinfo_t *pTexinfo = &texinfo[g_pFaces[pRadial->facenum].texinfo];
Vector vecTexU, vecTexV;
PreGetBumpNormalsForDisp( pTexinfo, vecTexU, vecTexV, normals[0] );
GetBumpNormals( vecTexU, vecTexV, normals[0], normals[0], &normals[1] );
if( bNeighborBump )
{
float flScale = patchNormal.Dot( normals[0] );
flScale = max( 0.0f, flScale );
float flBumpInfluence = influence * flScale;
for( int ndxBump = 0; ndxBump < ( NUM_BUMP_VECTS+1 ); ndxBump++ )
{
pRadial->light[ndxBump][ndxRadial].AddWeighted( pPatchLight[ndxBump], flBumpInfluence );
}
pRadial->weight[ndxRadial] += flBumpInfluence;
}
else
{
float flScale = patchNormal.Dot( normals[0] );
flScale = max( 0.0f, flScale );
float flBumpInfluence = influence * flScale * 0.05f;
for( int ndxBump = 0; ndxBump < ( NUM_BUMP_VECTS+1 ); ndxBump++ )
{
pRadial->light[ndxBump][ndxRadial].AddWeighted( pPatchLight[0], flBumpInfluence );
}
pRadial->weight[ndxRadial] += flBumpInfluence;
}
}
else
{
float flScale = patchNormal.Dot( luxelNormal );
flScale = max( 0.0f, flScale );
influence *= flScale;
pRadial->light[0][ndxRadial].AddWeighted( pPatchLight[0], influence );
// add the weight value
pRadial->weight[ndxRadial] += influence;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::RadialLuxelAddPatch( int ndxFace, Vector const &luxelPt,
Vector const &luxelNormal, float radius,
radial_t *pRadial, int ndxRadial, bool bBump,
CUtlVector<CPatch*> &interestingPatches )
{
#ifdef SAMPLEHASH_QUERY_ONCE
for ( int i=0; i < interestingPatches.Count(); i++ )
{
CPatch *pPatch = interestingPatches[i];
bool bNeighborBump = texinfo[g_pFaces[pPatch->faceNumber].texinfo].flags & SURF_BUMPLIGHT ? true : false;
Vector patchLight[NUM_BUMP_VECTS+1];
GetPatchLight( pPatch, bBump, patchLight );
AddPatchLightToRadial( pPatch->origin, pPatch->normal, patchLight, radius*radius,
luxelPt, luxelNormal, pRadial, ndxRadial, bBump, bNeighborBump );
}
#else
// calculate one over the voxel size
float ooVoxelSize = 1.0f / SAMPLEHASH_VOXEL_SIZE;
//
// find voxel info
//
int voxelMin[3], voxelMax[3];
for ( int axis = 0; axis < 3; axis++ )
{
voxelMin[axis] = ( int )( ( luxelPt[axis] - radius ) * ooVoxelSize );
voxelMax[axis] = ( int )( ( luxelPt[axis] + radius ) * ooVoxelSize ) + 1;
}
unsigned short curIterationKey = IncrementPatchIterationKey();
PatchSampleData_t patchData;
for ( int ndxZ = voxelMin[2]; ndxZ < voxelMax[2] + 1; ndxZ++ )
{
for ( int ndxY = voxelMin[1]; ndxY < voxelMax[1] + 1; ndxY++ )
{
for ( int ndxX = voxelMin[0]; ndxX < voxelMax[0] + 1; ndxX++ )
{
patchData.x = ndxX * 100;
patchData.y = ndxY * 10;
patchData.z = ndxZ;
UtlHashHandle_t handle = g_PatchSampleHashTable.Find( patchData );
if ( handle != g_PatchSampleHashTable.InvalidHandle() )
{
PatchSampleData_t *pPatchData = &g_PatchSampleHashTable.Element( handle );
int count = pPatchData->m_ndxPatches.Count();
for ( int ndx = 0; ndx < count; ndx++ )
{
int ndxPatch = pPatchData->m_ndxPatches.Element( ndx );
CPatch *pPatch = &g_Patches.Element( ndxPatch );
if ( pPatch && pPatch->m_IterationKey != curIterationKey )
{
pPatch->m_IterationKey = curIterationKey;
if ( IsNeighbor( ndxFace, pPatch->faceNumber ) )
{
bool bNeighborBump = texinfo[g_pFaces[pPatch->faceNumber].texinfo].flags & SURF_BUMPLIGHT ? true : false;
Vector patchLight[NUM_BUMP_VECTS+1];
GetPatchLight( pPatch, bBump, patchLight );
AddPatchLightToRadial( pPatch->origin, pPatch->normal, patchLight, radius*radius,
luxelPt, luxelNormal, pRadial, ndxRadial, bBump, bNeighborBump );
}
}
}
}
}
}
}
#endif
}
void CVRadDispMgr::GetInterestingPatchesForLuxels(
int ndxFace,
CUtlVector<CPatch*> &interestingPatches,
float patchSampleRadius )
{
facelight_t *pFaceLight = &facelight[ndxFace];
// Get the max bounds of all voxels that these luxels touch.
Vector vLuxelMin( FLT_MAX, FLT_MAX, FLT_MAX );
Vector vLuxelMax( -FLT_MAX, -FLT_MAX, -FLT_MAX );
for ( int i=0; i < pFaceLight->numluxels; i++ )
{
VectorMin( pFaceLight->luxel[i], vLuxelMin, vLuxelMin );
VectorMax( pFaceLight->luxel[i], vLuxelMax, vLuxelMax );
}
int allVoxelMin[3], allVoxelMax[3];
for ( int axis = 0; axis < 3; axis++ )
{
allVoxelMin[axis] = ( int )( ( vLuxelMin[axis] - patchSampleRadius ) / SAMPLEHASH_VOXEL_SIZE );
allVoxelMax[axis] = ( int )( ( vLuxelMax[axis] + patchSampleRadius ) / SAMPLEHASH_VOXEL_SIZE ) + 1;
}
int allVoxelSize[3] = { allVoxelMax[0] - allVoxelMin[0], allVoxelMax[1] - allVoxelMin[1], allVoxelMax[2] - allVoxelMin[2] };
// Now figure out exactly which voxels these luxels touch.
CUtlVector<unsigned char> voxelBits;
voxelBits.SetSize( ((allVoxelSize[0] * allVoxelSize[1] * allVoxelSize[2]) + 7) / 8 );
memset( voxelBits.Base(), 0, voxelBits.Count() );
for ( int i=0; i < pFaceLight->numluxels; i++ )
{
int voxelMin[3], voxelMax[3];
for ( int axis=0; axis < 3; axis++ )
{
voxelMin[axis] = ( int )( ( pFaceLight->luxel[i][axis] - patchSampleRadius ) / SAMPLEHASH_VOXEL_SIZE );
voxelMax[axis] = ( int )( ( pFaceLight->luxel[i][axis] + patchSampleRadius ) / SAMPLEHASH_VOXEL_SIZE ) + 1;
}
for ( int x=voxelMin[0]; x < voxelMax[0]; x++ )
{
for ( int y=voxelMin[1]; y < voxelMax[1]; y++ )
{
for ( int z=voxelMin[2]; z < voxelMax[2]; z++ )
{
int iBit = (z - allVoxelMin[2])*(allVoxelSize[0]*allVoxelSize[1]) +
(y-allVoxelMin[1])*allVoxelSize[0] +
(x-allVoxelMin[0]);
voxelBits[iBit>>3] |= (1 << (iBit & 7));
}
}
}
}
// Now get the list of patches that touch those voxels.
unsigned short curIterationKey = IncrementPatchIterationKey();
for ( int x=0; x < allVoxelSize[0]; x++ )
{
for ( int y=0; y < allVoxelSize[1]; y++ )
{
for ( int z=0; z < allVoxelSize[2]; z++ )
{
// Make sure this voxel has any luxels that care about it.
int iBit = z*(allVoxelSize[0]*allVoxelSize[1]) + y*allVoxelSize[0] + x;
unsigned char val = voxelBits[iBit>>3] & (1 << (iBit & 7));
if ( !val )
continue;
PatchSampleData_t patchData;
patchData.x = (x + allVoxelMin[0]) * 100;
patchData.y = (y + allVoxelMin[1]) * 10;
patchData.z = (z + allVoxelMin[2]);
UtlHashHandle_t handle = g_PatchSampleHashTable.Find( patchData );
if ( handle != g_PatchSampleHashTable.InvalidHandle() )
{
PatchSampleData_t *pPatchData = &g_PatchSampleHashTable.Element( handle );
// For all patches that touch this hash table element..
for ( int ndx = 0; ndx < pPatchData->m_ndxPatches.Count(); ndx++ )
{
int ndxPatch = pPatchData->m_ndxPatches.Element( ndx );
CPatch *pPatch = &g_Patches.Element( ndxPatch );
// If we haven't touched the patch already and it's a valid neighbor, then we want to use it.
if ( pPatch && pPatch->m_IterationKey != curIterationKey )
{
pPatch->m_IterationKey = curIterationKey;
if ( IsNeighbor( ndxFace, pPatch->faceNumber ) )
{
interestingPatches.AddToTail( pPatch );
}
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::RadialPatchBuild( CVRADDispColl *pDispTree, radial_t *pRadial,
bool bBump )
{
//
// get data lighting data
//
int ndxFace = pDispTree->GetParentIndex();
facelight_t *pFaceLight = &facelight[ndxFace];
// get the influence radius
float radius2 = pDispTree->GetPatchSampleRadius2();
float radius = ( float )sqrt( radius2 );
CUtlVector<CPatch*> interestingPatches;
#ifdef SAMPLEHASH_QUERY_ONCE
GetInterestingPatchesForLuxels( ndxFace, interestingPatches, radius );
#endif
int radialSize = pRadial->w * pRadial->h;
for( int ndxRadial = 0; ndxRadial < radialSize; ndxRadial++ )
{
RadialLuxelAddPatch(
ndxFace,
pFaceLight->luxel[ndxRadial],
pFaceLight->luxelNormals[ndxRadial],
radius,
pRadial,
ndxRadial,
bBump,
interestingPatches );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
radial_t *CVRadDispMgr::BuildPatchRadial( int ndxFace, bool bBump )
{
// allocate the radial
radial_t *pRadial = AllocateRadial( ndxFace );
if( !pRadial )
return NULL;
//
// step 1: get the displacement surface to be lit
//
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return NULL;
// step 2: build radial of patch light
RadialPatchBuild( pDispTree, pRadial, bBump );
// step 3: return the built radial
return pRadial;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool SampleInSolid( sample_t *pSample )
{
int ndxLeaf = PointLeafnum( pSample->pos );
return ( dleafs[ndxLeaf].contents == CONTENTS_SOLID );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::InsertSamplesDataIntoHashTable( void )
{
int totalSamples = 0;
#if 0
int totalSamplesInSolid = 0;
#endif
for( int ndxFace = 0; ndxFace < numfaces; ndxFace++ )
{
dface_t *pFace = &g_pFaces[ndxFace];
facelight_t *pFaceLight = &facelight[ndxFace];
if( !pFace || !pFaceLight )
continue;
if( texinfo[pFace->texinfo].flags & TEX_SPECIAL )
continue;
#if 0
bool bDisp = ( pFace->dispinfo != -1 );
#endif
//
// for each sample
//
for( int ndxSample = 0; ndxSample < pFaceLight->numsamples; ndxSample++ )
{
sample_t *pSample = &pFaceLight->sample[ndxSample];
if( pSample )
{
#if 0
if( bDisp )
{
// test sample to see if the displacement samples resides in solid
if( SampleInSolid( pSample ) )
{
totalSamplesInSolid++;
continue;
}
}
#endif
// create the sample handle
SampleHandle_t sampleHandle = ndxSample;
sampleHandle |= ( ndxFace << 16 );
SampleData_AddSample( pSample, sampleHandle );
}
}
totalSamples += pFaceLight->numsamples;
}
#if 0
// not implemented yet!!!
Msg( "%d samples in solid\n", totalSamplesInSolid );
#endif
// log the distribution
SampleData_Log();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::InsertPatchSampleDataIntoHashTable( void )
{
// don't insert patch samples if we are not bouncing light
if( numbounce <= 0 )
return;
int totalPatchSamples = 0;
for( int ndxFace = 0; ndxFace < numfaces; ndxFace++ )
{
dface_t *pFace = &g_pFaces[ndxFace];
facelight_t *pFaceLight = &facelight[ndxFace];
if( !pFace || !pFaceLight )
continue;
if( texinfo[pFace->texinfo].flags & TEX_SPECIAL )
continue;
//
// for each patch
//
CPatch *pNextPatch = NULL;
if( g_FacePatches.Element( ndxFace ) != g_FacePatches.InvalidIndex() )
{
for( CPatch *pPatch = &g_Patches.Element( g_FacePatches.Element( ndxFace ) ); pPatch; pPatch = pNextPatch )
{
// next patch
pNextPatch = NULL;
if( pPatch->ndxNext != g_Patches.InvalidIndex() )
{
pNextPatch = &g_Patches.Element( pPatch->ndxNext );
}
// skip patches with children
if( pPatch->child1 != g_Patches.InvalidIndex() )
continue;
int ndxPatch = pPatch - g_Patches.Base();
PatchSampleData_AddSample( pPatch, ndxPatch );
totalPatchSamples++;
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::StartTimer( const char *name )
{
Msg( name );
m_Timer.Start();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CVRadDispMgr::EndTimer( void )
{
m_Timer.End();
CCycleCount duration = m_Timer.GetDuration();
double seconds = duration.GetSeconds();
Msg( "Done<%1.4lf sec>\n", seconds );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::BuildDispSamples( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace )
{
// get the tree assosciated with the face
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return false;
// lightmap size
int width = pLightInfo->face->m_LightmapTextureSizeInLuxels[0]+1;
int height = pLightInfo->face->m_LightmapTextureSizeInLuxels[1]+1;
// calculate the steps in uv space
float stepU = 1.0f / ( float )width;
float stepV = 1.0f / ( float )height;
float halfStepU = stepU * 0.5f;
float halfStepV = stepV * 0.5f;
//
// build the winding points (used to generate world space winding and
// calculate the area of the "sample")
//
int ndxU, ndxV;
CUtlVector<sample_t> samples;
samples.SetCount( SINGLEMAP );
sample_t *pSamples = samples.Base();
CUtlVector<Vector> worldPoints;
worldPoints.SetCount( SINGLEMAP );
Vector *pWorldPoints = worldPoints.Base();
for( ndxV = 0; ndxV < ( height + 1 ); ndxV++ )
{
for( ndxU = 0; ndxU < ( width + 1 ); ndxU++ )
{
int ndx = ( ndxV * ( width + 1 ) ) + ndxU;
Vector2D uv( ndxU * stepU, ndxV * stepV );
pDispTree->DispUVToSurfPoint( uv, pWorldPoints[ndx], 0.0f );
}
}
for( ndxV = 0; ndxV < height; ndxV++ )
{
for( ndxU = 0; ndxU < width; ndxU++ )
{
// build the winding
winding_t *pWinding = AllocWinding( 4 );
if( pWinding )
{
pWinding->numpoints = 4;
pWinding->p[0] = pWorldPoints[(ndxV*(width+1))+ndxU];
pWinding->p[1] = pWorldPoints[((ndxV+1)*(width+1))+ndxU];
pWinding->p[2] = pWorldPoints[((ndxV+1)*(width+1))+(ndxU+1)];
pWinding->p[3] = pWorldPoints[(ndxV*(width+1))+(ndxU+1)];
// calculate the area
float area = WindingArea( pWinding );
int ndxSample = ( ndxV * width ) + ndxU;
pSamples[ndxSample].w = pWinding;
pSamples[ndxSample].area = area;
}
else
{
Msg( "BuildDispSamples: WARNING - failed winding allocation\n" );
}
}
}
//
// build the samples points (based on s, t and sampleoffset (center of samples);
// generates world space position and normal)
//
for( ndxV = 0; ndxV < height; ndxV++ )
{
for( ndxU = 0; ndxU < width; ndxU++ )
{
int ndxSample = ( ndxV * width ) + ndxU;
pSamples[ndxSample].s = ndxU;
pSamples[ndxSample].t = ndxV;
pSamples[ndxSample].coord[0] = ( ndxU * stepU ) + halfStepU;
pSamples[ndxSample].coord[1] = ( ndxV * stepV ) + halfStepV;
pDispTree->DispUVToSurfPoint( pSamples[ndxSample].coord, pSamples[ndxSample].pos, 1.0f );
pDispTree->DispUVToSurfNormal( pSamples[ndxSample].coord, pSamples[ndxSample].normal );
}
}
//
// copy over samples
//
pFaceLight->numsamples = width * height;
pFaceLight->sample = ( sample_t* )calloc( pFaceLight->numsamples, sizeof( *pFaceLight->sample ) );
if( !pFaceLight->sample )
return false;
memcpy( pFaceLight->sample, pSamples, pFaceLight->numsamples * sizeof( *pFaceLight->sample ) );
// statistics - warning?!
if( pFaceLight->numsamples == 0 )
{
Msg( "BuildDispSamples: WARNING - no samples %d\n", pLightInfo->face - g_pFaces );
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::BuildDispLuxels( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace )
{
// get the tree assosciated with the face
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return false;
// lightmap size
int width = pLightInfo->face->m_LightmapTextureSizeInLuxels[0]+1;
int height = pLightInfo->face->m_LightmapTextureSizeInLuxels[1]+1;
// calcuate actual luxel points
pFaceLight->numluxels = width * height;
pFaceLight->luxel = ( Vector* )calloc( pFaceLight->numluxels, sizeof( *pFaceLight->luxel ) );
pFaceLight->luxelNormals = ( Vector* )calloc( pFaceLight->numluxels, sizeof( Vector ) );
if( !pFaceLight->luxel || !pFaceLight->luxelNormals )
return false;
float stepU = 1.0f / ( float )( width - 1 );
float stepV = 1.0f / ( float )( height - 1 );
for( int ndxV = 0; ndxV < height; ndxV++ )
{
for( int ndxU = 0; ndxU < width; ndxU++ )
{
int ndxLuxel = ( ndxV * width ) + ndxU;
Vector2D uv( ndxU * stepU, ndxV * stepV );
pDispTree->DispUVToSurfPoint( uv, pFaceLight->luxel[ndxLuxel], 1.0f );
pDispTree->DispUVToSurfNormal( uv, pFaceLight->luxelNormals[ndxLuxel] );
}
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CVRadDispMgr::BuildDispSamplesAndLuxels_DoFast( lightinfo_t *pLightInfo, facelight_t *pFaceLight, int ndxFace )
{
// get the tree assosciated with the face
DispCollTree_t &dispTree = m_DispTrees[g_pFaces[ndxFace].dispinfo];
CVRADDispColl *pDispTree = dispTree.m_pDispTree;
if( !pDispTree )
return false;
// lightmap size
int width = pLightInfo->face->m_LightmapTextureSizeInLuxels[0]+1;
int height = pLightInfo->face->m_LightmapTextureSizeInLuxels[1]+1;
// calcuate actual luxel points
pFaceLight->numsamples = width * height;
pFaceLight->sample = ( sample_t* )calloc( pFaceLight->numsamples, sizeof( *pFaceLight->sample ) );
if( !pFaceLight->sample )
return false;
pFaceLight->numluxels = width * height;
pFaceLight->luxel = ( Vector* )calloc( pFaceLight->numluxels, sizeof( *pFaceLight->luxel ) );
pFaceLight->luxelNormals = ( Vector* )calloc( pFaceLight->numluxels, sizeof( Vector ) );
if( !pFaceLight->luxel || !pFaceLight->luxelNormals )
return false;
float stepU = 1.0f / ( float )( width - 1 );
float stepV = 1.0f / ( float )( height - 1 );
float halfStepU = stepU * 0.5f;
float halfStepV = stepV * 0.5f;
for( int ndxV = 0; ndxV < height; ndxV++ )
{
for( int ndxU = 0; ndxU < width; ndxU++ )
{
int ndx = ( ndxV * width ) + ndxU;
pFaceLight->sample[ndx].s = ndxU;
pFaceLight->sample[ndx].t = ndxV;
pFaceLight->sample[ndx].coord[0] = ( ndxU * stepU ) + halfStepU;
pFaceLight->sample[ndx].coord[1] = ( ndxV * stepV ) + halfStepV;
pDispTree->DispUVToSurfPoint( pFaceLight->sample[ndx].coord, pFaceLight->sample[ndx].pos, 1.0f );
pDispTree->DispUVToSurfNormal( pFaceLight->sample[ndx].coord, pFaceLight->sample[ndx].normal );
pFaceLight->luxel[ndx] = pFaceLight->sample[ndx].pos;
pFaceLight->luxelNormals[ndx] = pFaceLight->sample[ndx].normal;
}
}
return true;
}