source-engine-2018-hl2_src/game/client/clientshadowmgr.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

4336 lines
146 KiB
C++

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
// Interface to the client system responsible for dealing with shadows
//
// Boy is this complicated. OK, lets talk about how this works at the moment
//
// The ClientShadowMgr contains all of the highest-level state for rendering
// shadows, and it controls the ShadowMgr in the engine which is the central
// clearing house for rendering shadows.
//
// There are two important types of objects with respect to shadows:
// the shadow receiver, and the shadow caster. How is the association made
// between casters + the receivers? Turns out it's done slightly differently
// depending on whether the receiver is the world, or if it's an entity.
//
// In the case of the world, every time the engine's ProjectShadow() is called,
// any previous receiver state stored (namely, which world surfaces are
// receiving shadows) are cleared. Then, when ProjectShadow is called,
// the engine iterates over all nodes + leaves within the shadow volume and
// marks front-facing surfaces in them as potentially being affected by the
// shadow. Later on, if those surfaces are actually rendered, the surfaces
// are clipped by the shadow volume + rendered.
//
// In the case of entities, there are slightly different methods depending
// on whether the receiver is a brush model or a studio model. However, there
// are a couple central things that occur with both.
//
// Every time a shadow caster is moved, the ClientLeafSystem's ProjectShadow
// method is called to tell it to remove the shadow from all leaves + all
// renderables it's currently associated with. Then it marks each leaf in the
// shadow volume as being affected by that shadow, and it marks every renderable
// in that volume as being potentially affected by the shadow (the function
// AddShadowToRenderable is called for each renderable in leaves affected
// by the shadow volume).
//
// Every time a shadow receiver is moved, the ClientLeafSystem first calls
// RemoveAllShadowsFromRenderable to have it clear out its state, and then
// the ClientLeafSystem calls AddShadowToRenderable() for all shadows in all
// leaves the renderable has moved into.
//
// Now comes the difference between brush models + studio models. In the case
// of brush models, when a shadow is added to the studio model, it's done in
// the exact same way as for the world. Surfaces on the brush model are marked
// as potentially being affected by the shadow, and if those surfaces are
// rendered, the surfaces are clipped to the shadow volume. When ProjectShadow()
// is called, turns out the same operation that removes the shadow that moved
// from the world surfaces also works to remove the shadow from brush surfaces.
//
// In the case of studio models, we need a separate operation to remove
// the shadow from all studio models
//===========================================================================//
#include "cbase.h"
#include "engine/ishadowmgr.h"
#include "model_types.h"
#include "bitmap/imageformat.h"
#include "materialsystem/imaterialproxy.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imesh.h"
#include "materialsystem/itexture.h"
#include "bsptreedata.h"
#include "utlmultilist.h"
#include "collisionutils.h"
#include "iviewrender.h"
#include "ivrenderview.h"
#include "tier0/vprof.h"
#include "engine/ivmodelinfo.h"
#include "view_shared.h"
#include "engine/ivdebugoverlay.h"
#include "engine/IStaticPropMgr.h"
#include "datacache/imdlcache.h"
#include "viewrender.h"
#include "tier0/icommandline.h"
#include "vstdlib/jobthread.h"
#include "toolframework_client.h"
#include "bonetoworldarray.h"
#include "cmodel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar r_flashlightdrawfrustum( "r_flashlightdrawfrustum", "0" );
static ConVar r_flashlightmodels( "r_flashlightmodels", "1" );
static ConVar r_shadowrendertotexture( "r_shadowrendertotexture", "0" );
static ConVar r_flashlight_version2( "r_flashlight_version2", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar r_flashlightdepthtexture( "r_flashlightdepthtexture", "1", FCVAR_ALLOWED_IN_COMPETITIVE );
#if defined( _X360 )
ConVar r_flashlightdepthres( "r_flashlightdepthres", "512" );
#else
ConVar r_flashlightdepthres( "r_flashlightdepthres", "1024" );
#endif
ConVar r_threaded_client_shadow_manager( "r_threaded_client_shadow_manager", "0" );
#ifdef _WIN32
#pragma warning( disable: 4701 )
#endif
// forward declarations
void ToolFramework_RecordMaterialParams( IMaterial *pMaterial );
//-----------------------------------------------------------------------------
// A texture allocator used to batch textures together
// At the moment, the implementation simply allocates blocks of max 256x256
// and each block stores an array of uniformly-sized textures
//-----------------------------------------------------------------------------
typedef unsigned short TextureHandle_t;
enum
{
INVALID_TEXTURE_HANDLE = (TextureHandle_t)~0
};
class CTextureAllocator
{
public:
// Initialize the allocator with something that knows how to refresh the bits
void Init();
void Shutdown();
// Resets the allocator
void Reset();
// Deallocates everything
void DeallocateAllTextures();
// Allocate, deallocate texture
TextureHandle_t AllocateTexture( int w, int h );
void DeallocateTexture( TextureHandle_t h );
// Mark texture as being used... (return true if re-render is needed)
bool UseTexture( TextureHandle_t h, bool bWillRedraw, float flArea );
bool HasValidTexture( TextureHandle_t h );
// Advance frame...
void AdvanceFrame();
// Get at the location of the texture
void GetTextureRect(TextureHandle_t handle, int& x, int& y, int& w, int& h );
// Get at the texture it's a part of
ITexture *GetTexture();
// Get at the total texture size.
void GetTotalTextureSize( int& w, int& h );
void DebugPrintCache( void );
private:
typedef unsigned short FragmentHandle_t;
enum
{
INVALID_FRAGMENT_HANDLE = (FragmentHandle_t)~0,
TEXTURE_PAGE_SIZE = 1024,
MAX_TEXTURE_POWER = 8,
#if !defined( _X360 )
MIN_TEXTURE_POWER = 4,
#else
MIN_TEXTURE_POWER = 5, // per resolve requirements to ensure 32x32 aligned offsets
#endif
MAX_TEXTURE_SIZE = (1 << MAX_TEXTURE_POWER),
MIN_TEXTURE_SIZE = (1 << MIN_TEXTURE_POWER),
BLOCK_SIZE = MAX_TEXTURE_SIZE,
BLOCKS_PER_ROW = (TEXTURE_PAGE_SIZE / MAX_TEXTURE_SIZE),
BLOCK_COUNT = (BLOCKS_PER_ROW * BLOCKS_PER_ROW),
};
struct TextureInfo_t
{
FragmentHandle_t m_Fragment;
unsigned short m_Size;
unsigned short m_Power;
};
struct FragmentInfo_t
{
unsigned short m_Block;
unsigned short m_Index;
TextureHandle_t m_Texture;
// Makes sure we don't overflow
unsigned int m_FrameUsed;
};
struct BlockInfo_t
{
unsigned short m_FragmentPower;
};
struct Cache_t
{
unsigned short m_List;
};
// Adds a block worth of fragments to the LRU
void AddBlockToLRU( int block );
// Unlink fragment from cache
void UnlinkFragmentFromCache( Cache_t& cache, FragmentHandle_t fragment );
// Mark something as being used (MRU)..
void MarkUsed( FragmentHandle_t fragment );
// Mark something as being unused (LRU)..
void MarkUnused( FragmentHandle_t fragment );
// Disconnect texture from fragment
void DisconnectTextureFromFragment( FragmentHandle_t f );
// Returns the size of a particular fragment
int GetFragmentPower( FragmentHandle_t f ) const;
// Stores the actual texture we're writing into
CTextureReference m_TexturePage;
CUtlLinkedList< TextureInfo_t, TextureHandle_t > m_Textures;
CUtlMultiList< FragmentInfo_t, FragmentHandle_t > m_Fragments;
Cache_t m_Cache[MAX_TEXTURE_POWER+1];
BlockInfo_t m_Blocks[BLOCK_COUNT];
unsigned int m_CurrentFrame;
};
//-----------------------------------------------------------------------------
// Allocate/deallocate the texture page
//-----------------------------------------------------------------------------
void CTextureAllocator::Init()
{
for ( int i = 0; i <= MAX_TEXTURE_POWER; ++i )
{
m_Cache[i].m_List = m_Fragments.InvalidIndex();
}
#if !defined( _X360 )
// don't need depth buffer for shadows
m_TexturePage.InitRenderTarget( TEXTURE_PAGE_SIZE, TEXTURE_PAGE_SIZE, RT_SIZE_NO_CHANGE, IMAGE_FORMAT_ARGB8888, MATERIAL_RT_DEPTH_NONE, false, "_rt_Shadows" );
#else
// unfortunate explicit management required for this render target
// 32bpp edram is only largest shadow fragment, but resolved to actual shadow atlas
// because full-res 1024x1024 shadow buffer is too large for EDRAM
m_TexturePage.InitRenderTargetTexture( TEXTURE_PAGE_SIZE, TEXTURE_PAGE_SIZE, RT_SIZE_NO_CHANGE, IMAGE_FORMAT_ARGB8888, MATERIAL_RT_DEPTH_NONE, false, "_rt_Shadows" );
// edram footprint is only 256x256x4 = 256K
m_TexturePage.InitRenderTargetSurface( MAX_TEXTURE_SIZE, MAX_TEXTURE_SIZE, IMAGE_FORMAT_ARGB8888, false );
// due to texture/surface size mismatch, ensure texture page is entirely cleared translucent
// otherwise border artifacts at edge of shadows due to pixel shader averaging of unwanted bits
m_TexturePage->ClearTexture( 0, 0, 0, 0 );
#endif
}
void CTextureAllocator::Shutdown()
{
m_TexturePage.Shutdown();
}
//-----------------------------------------------------------------------------
// Initialize the allocator with something that knows how to refresh the bits
//-----------------------------------------------------------------------------
void CTextureAllocator::Reset()
{
DeallocateAllTextures();
m_Textures.EnsureCapacity(256);
m_Fragments.EnsureCapacity(256);
// Set up the block sizes....
// FIXME: Improve heuristic?!?
#if !defined( _X360 )
m_Blocks[0].m_FragmentPower = MAX_TEXTURE_POWER-4; // 128 cells at ExE resolution
#else
m_Blocks[0].m_FragmentPower = MAX_TEXTURE_POWER-3; // 64 cells at DxD resolution
#endif
m_Blocks[1].m_FragmentPower = MAX_TEXTURE_POWER-3; // 64 cells at DxD resolution
m_Blocks[2].m_FragmentPower = MAX_TEXTURE_POWER-2; // 32 cells at CxC resolution
m_Blocks[3].m_FragmentPower = MAX_TEXTURE_POWER-2;
m_Blocks[4].m_FragmentPower = MAX_TEXTURE_POWER-1; // 24 cells at BxB resolution
m_Blocks[5].m_FragmentPower = MAX_TEXTURE_POWER-1;
m_Blocks[6].m_FragmentPower = MAX_TEXTURE_POWER-1;
m_Blocks[7].m_FragmentPower = MAX_TEXTURE_POWER-1;
m_Blocks[8].m_FragmentPower = MAX_TEXTURE_POWER-1;
m_Blocks[9].m_FragmentPower = MAX_TEXTURE_POWER-1;
m_Blocks[10].m_FragmentPower = MAX_TEXTURE_POWER; // 6 cells at AxA resolution
m_Blocks[11].m_FragmentPower = MAX_TEXTURE_POWER;
m_Blocks[12].m_FragmentPower = MAX_TEXTURE_POWER;
m_Blocks[13].m_FragmentPower = MAX_TEXTURE_POWER;
m_Blocks[14].m_FragmentPower = MAX_TEXTURE_POWER;
m_Blocks[15].m_FragmentPower = MAX_TEXTURE_POWER;
// Initialize the LRU
int i;
for ( i = 0; i <= MAX_TEXTURE_POWER; ++i )
{
m_Cache[i].m_List = m_Fragments.CreateList();
}
// Now that the block sizes are allocated, create LRUs for the various block sizes
for ( i = 0; i < BLOCK_COUNT; ++i)
{
// Initialize LRU
AddBlockToLRU( i );
}
m_CurrentFrame = 0;
}
void CTextureAllocator::DeallocateAllTextures()
{
m_Textures.Purge();
m_Fragments.Purge();
for ( int i = 0; i <= MAX_TEXTURE_POWER; ++i )
{
m_Cache[i].m_List = m_Fragments.InvalidIndex();
}
}
//-----------------------------------------------------------------------------
// Dump the state of the cache to debug out
//-----------------------------------------------------------------------------
void CTextureAllocator::DebugPrintCache( void )
{
// For each fragment
int nNumFragments = m_Fragments.TotalCount();
int nNumInvalidFragments = 0;
Warning("Fragments (%d):\n===============\n", nNumFragments);
for ( int f = 0; f < nNumFragments; f++ )
{
if ( ( m_Fragments[f].m_FrameUsed != 0 ) && ( m_Fragments[f].m_Texture != INVALID_TEXTURE_HANDLE ) )
Warning("Fragment %d, Block: %d, Index: %d, Texture: %d Frame Used: %d\n", f, m_Fragments[f].m_Block, m_Fragments[f].m_Index, m_Fragments[f].m_Texture, m_Fragments[f].m_FrameUsed );
else
nNumInvalidFragments++;
}
Warning("Invalid Fragments: %d\n", nNumInvalidFragments);
// for ( int c = 0; c <= MAX_TEXTURE_POWER; ++c )
// {
// Warning("Cache Index (%d)\n", m_Cache[c].m_List);
// }
}
//-----------------------------------------------------------------------------
// Adds a block worth of fragments to the LRU
//-----------------------------------------------------------------------------
void CTextureAllocator::AddBlockToLRU( int block )
{
int power = m_Blocks[block].m_FragmentPower;
int size = (1 << power);
// Compute the number of fragments in this block
int fragmentCount = MAX_TEXTURE_SIZE / size;
fragmentCount *= fragmentCount;
// For each fragment, indicate which block it's a part of (and the index)
// and then stick in at the top of the LRU
while (--fragmentCount >= 0 )
{
FragmentHandle_t f = m_Fragments.Alloc( );
m_Fragments[f].m_Block = block;
m_Fragments[f].m_Index = fragmentCount;
m_Fragments[f].m_Texture = INVALID_TEXTURE_HANDLE;
m_Fragments[f].m_FrameUsed = 0xFFFFFFFF;
m_Fragments.LinkToHead( m_Cache[power].m_List, f );
}
}
//-----------------------------------------------------------------------------
// Unlink fragment from cache
//-----------------------------------------------------------------------------
void CTextureAllocator::UnlinkFragmentFromCache( Cache_t& cache, FragmentHandle_t fragment )
{
m_Fragments.Unlink( cache.m_List, fragment);
}
//-----------------------------------------------------------------------------
// Mark something as being used (MRU)..
//-----------------------------------------------------------------------------
void CTextureAllocator::MarkUsed( FragmentHandle_t fragment )
{
int block = m_Fragments[fragment].m_Block;
int power = m_Blocks[block].m_FragmentPower;
// Hook it at the end of the LRU
Cache_t& cache = m_Cache[power];
m_Fragments.LinkToTail( cache.m_List, fragment );
m_Fragments[fragment].m_FrameUsed = m_CurrentFrame;
}
//-----------------------------------------------------------------------------
// Mark something as being unused (LRU)..
//-----------------------------------------------------------------------------
void CTextureAllocator::MarkUnused( FragmentHandle_t fragment )
{
int block = m_Fragments[fragment].m_Block;
int power = m_Blocks[block].m_FragmentPower;
// Hook it at the end of the LRU
Cache_t& cache = m_Cache[power];
m_Fragments.LinkToHead( cache.m_List, fragment );
}
//-----------------------------------------------------------------------------
// Allocate, deallocate texture
//-----------------------------------------------------------------------------
TextureHandle_t CTextureAllocator::AllocateTexture( int w, int h )
{
// Implementational detail for now
Assert( w == h );
// Clamp texture size
if (w < MIN_TEXTURE_SIZE)
w = MIN_TEXTURE_SIZE;
else if (w > MAX_TEXTURE_SIZE)
w = MAX_TEXTURE_SIZE;
TextureHandle_t handle = m_Textures.AddToTail();
m_Textures[handle].m_Fragment = INVALID_FRAGMENT_HANDLE;
m_Textures[handle].m_Size = w;
// Find the power of two
int power = 0;
int size = 1;
while(size < w)
{
size <<= 1;
++power;
}
Assert( size == w );
m_Textures[handle].m_Power = power;
return handle;
}
void CTextureAllocator::DeallocateTexture( TextureHandle_t h )
{
// Warning("Beginning of DeallocateTexture\n");
// DebugPrintCache();
if (m_Textures[h].m_Fragment != INVALID_FRAGMENT_HANDLE)
{
MarkUnused(m_Textures[h].m_Fragment);
m_Fragments[m_Textures[h].m_Fragment].m_FrameUsed = 0xFFFFFFFF; // non-zero frame
DisconnectTextureFromFragment( m_Textures[h].m_Fragment );
}
m_Textures.Remove(h);
// Warning("End of DeallocateTexture\n");
// DebugPrintCache();
}
//-----------------------------------------------------------------------------
// Disconnect texture from fragment
//-----------------------------------------------------------------------------
void CTextureAllocator::DisconnectTextureFromFragment( FragmentHandle_t f )
{
// Warning( "Beginning of DisconnectTextureFromFragment\n" );
// DebugPrintCache();
FragmentInfo_t& info = m_Fragments[f];
if (info.m_Texture != INVALID_TEXTURE_HANDLE)
{
m_Textures[info.m_Texture].m_Fragment = INVALID_FRAGMENT_HANDLE;
info.m_Texture = INVALID_TEXTURE_HANDLE;
}
// Warning( "End of DisconnectTextureFromFragment\n" );
// DebugPrintCache();
}
//-----------------------------------------------------------------------------
// Do we have a valid texture assigned?
//-----------------------------------------------------------------------------
bool CTextureAllocator::HasValidTexture( TextureHandle_t h )
{
TextureInfo_t& info = m_Textures[h];
FragmentHandle_t currentFragment = info.m_Fragment;
return (currentFragment != INVALID_FRAGMENT_HANDLE);
}
//-----------------------------------------------------------------------------
// Mark texture as being used...
//-----------------------------------------------------------------------------
bool CTextureAllocator::UseTexture( TextureHandle_t h, bool bWillRedraw, float flArea )
{
// Warning( "Top of UseTexture\n" );
// DebugPrintCache();
TextureInfo_t& info = m_Textures[h];
// spin up to the best fragment size
int nDesiredPower = MIN_TEXTURE_POWER;
int nDesiredWidth = MIN_TEXTURE_SIZE;
while ( (nDesiredWidth * nDesiredWidth) < flArea )
{
if ( nDesiredPower >= info.m_Power )
{
nDesiredPower = info.m_Power;
break;
}
++nDesiredPower;
nDesiredWidth <<= 1;
}
// If we've got a valid fragment for this texture, no worries!
int nCurrentPower = -1;
FragmentHandle_t currentFragment = info.m_Fragment;
if (currentFragment != INVALID_FRAGMENT_HANDLE)
{
// If the current fragment is at or near the desired power, we're done
nCurrentPower = GetFragmentPower(info.m_Fragment);
Assert( nCurrentPower <= info.m_Power );
bool bShouldKeepTexture = (!bWillRedraw) && (nDesiredPower < 8) && (nDesiredPower - nCurrentPower <= 1);
if ((nCurrentPower == nDesiredPower) || bShouldKeepTexture)
{
// Move to the back of the LRU
MarkUsed( currentFragment );
return false;
}
}
// Warning( "\n\nUseTexture B\n" );
// DebugPrintCache();
// Grab the LRU fragment from the appropriate cache
// If that fragment is connected to a texture, disconnect it.
int power = nDesiredPower;
FragmentHandle_t f = INVALID_FRAGMENT_HANDLE;
bool done = false;
while (!done && power >= 0)
{
f = m_Fragments.Head( m_Cache[power].m_List );
// This represents an overflow condition (used too many textures of
// the same size in a single frame). It that happens, just use a texture
// of lower res.
if ( (f != m_Fragments.InvalidIndex()) && (m_Fragments[f].m_FrameUsed != m_CurrentFrame) )
{
done = true;
}
else
{
--power;
}
}
// Warning( "\n\nUseTexture C\n" );
// DebugPrintCache();
// Ok, lets see if we're better off than we were...
if (currentFragment != INVALID_FRAGMENT_HANDLE)
{
if (power <= nCurrentPower)
{
// Oops... we're not. Let's leave well enough alone
// Move to the back of the LRU
MarkUsed( currentFragment );
return false;
}
else
{
// Clear out the old fragment
DisconnectTextureFromFragment(currentFragment);
}
}
if ( f == INVALID_FRAGMENT_HANDLE )
{
return false;
}
// Disconnect existing texture from this fragment (if necessary)
DisconnectTextureFromFragment(f);
// Connnect new texture to this fragment
info.m_Fragment = f;
m_Fragments[f].m_Texture = h;
// Move to the back of the LRU
MarkUsed( f );
// Indicate we need a redraw
return true;
}
//-----------------------------------------------------------------------------
// Returns the size of a particular fragment
//-----------------------------------------------------------------------------
int CTextureAllocator::GetFragmentPower( FragmentHandle_t f ) const
{
return m_Blocks[m_Fragments[f].m_Block].m_FragmentPower;
}
//-----------------------------------------------------------------------------
// Advance frame...
//-----------------------------------------------------------------------------
void CTextureAllocator::AdvanceFrame()
{
// Be sure that this is called as infrequently as possible (i.e. once per frame,
// NOT once per view) to prevent cache thrash when rendering multiple views in a single frame
m_CurrentFrame++;
}
//-----------------------------------------------------------------------------
// Prepare to render into texture...
//-----------------------------------------------------------------------------
ITexture* CTextureAllocator::GetTexture()
{
return m_TexturePage;
}
//-----------------------------------------------------------------------------
// Get at the total texture size.
//-----------------------------------------------------------------------------
void CTextureAllocator::GetTotalTextureSize( int& w, int& h )
{
w = h = TEXTURE_PAGE_SIZE;
}
//-----------------------------------------------------------------------------
// Returns the rectangle the texture lives in..
//-----------------------------------------------------------------------------
void CTextureAllocator::GetTextureRect(TextureHandle_t handle, int& x, int& y, int& w, int& h )
{
TextureInfo_t& info = m_Textures[handle];
Assert( info.m_Fragment != INVALID_FRAGMENT_HANDLE );
// Compute the position of the fragment in the page
FragmentInfo_t& fragment = m_Fragments[info.m_Fragment];
int blockY = fragment.m_Block / BLOCKS_PER_ROW;
int blockX = fragment.m_Block - blockY * BLOCKS_PER_ROW;
int fragmentSize = (1 << m_Blocks[fragment.m_Block].m_FragmentPower);
int fragmentsPerRow = BLOCK_SIZE / fragmentSize;
int fragmentY = fragment.m_Index / fragmentsPerRow;
int fragmentX = fragment.m_Index - fragmentY * fragmentsPerRow;
x = blockX * BLOCK_SIZE + fragmentX * fragmentSize;
y = blockY * BLOCK_SIZE + fragmentY * fragmentSize;
w = fragmentSize;
h = fragmentSize;
}
//-----------------------------------------------------------------------------
// Defines how big of a shadow texture we should be making per caster...
//-----------------------------------------------------------------------------
#define TEXEL_SIZE_PER_CASTER_SIZE 2.0f
#define MAX_FALLOFF_AMOUNT 240
#define MAX_CLIP_PLANE_COUNT 4
#define SHADOW_CULL_TOLERANCE 0.5f
static ConVar r_shadows( "r_shadows", "1" ); // hook into engine's cvars..
static ConVar r_shadowmaxrendered("r_shadowmaxrendered", "32");
static ConVar r_shadows_gamecontrol( "r_shadows_gamecontrol", "-1", FCVAR_CHEAT ); // hook into engine's cvars..
//-----------------------------------------------------------------------------
// The class responsible for dealing with shadows on the client side
// Oh, and let's take a moment and notice how happy Robin and John must be
// owing to the lack of space between this lovely comment and the class name =)
//-----------------------------------------------------------------------------
class CClientShadowMgr : public IClientShadowMgr
{
public:
CClientShadowMgr();
virtual char const *Name() { return "CCLientShadowMgr"; }
// Inherited from IClientShadowMgr
virtual bool Init();
virtual void PostInit() {}
virtual void Shutdown();
virtual void LevelInitPreEntity();
virtual void LevelInitPostEntity() {}
virtual void LevelShutdownPreEntity() {}
virtual void LevelShutdownPostEntity();
virtual bool IsPerFrame() { return true; }
virtual void PreRender();
virtual void Update( float frametime ) { }
virtual void PostRender() {}
virtual void OnSave() {}
virtual void OnRestore() {}
virtual void SafeRemoveIfDesired() {}
virtual ClientShadowHandle_t CreateShadow( ClientEntityHandle_t entity, int flags );
virtual void DestroyShadow( ClientShadowHandle_t handle );
// Create flashlight (projected texture light source)
virtual ClientShadowHandle_t CreateFlashlight( const FlashlightState_t &lightState );
virtual void UpdateFlashlightState( ClientShadowHandle_t shadowHandle, const FlashlightState_t &lightState );
virtual void DestroyFlashlight( ClientShadowHandle_t shadowHandle );
// Update a shadow
virtual void UpdateProjectedTexture( ClientShadowHandle_t handle, bool force );
void ComputeBoundingSphere( IClientRenderable* pRenderable, Vector& origin, float& radius );
virtual void AddToDirtyShadowList( ClientShadowHandle_t handle, bool bForce );
virtual void AddToDirtyShadowList( IClientRenderable *pRenderable, bool force );
// Marks the render-to-texture shadow as needing to be re-rendered
virtual void MarkRenderToTextureShadowDirty( ClientShadowHandle_t handle );
// deals with shadows being added to shadow receivers
void AddShadowToReceiver( ClientShadowHandle_t handle,
IClientRenderable* pRenderable, ShadowReceiver_t type );
// deals with shadows being added to shadow receivers
void RemoveAllShadowsFromReceiver( IClientRenderable* pRenderable, ShadowReceiver_t type );
// Re-renders all shadow textures for shadow casters that lie in the leaf list
void ComputeShadowTextures( const CViewSetup &view, int leafCount, LeafIndex_t* pLeafList );
// Kicks off rendering into shadow depth maps (if any)
void ComputeShadowDepthTextures( const CViewSetup &view );
// Frees shadow depth textures for use in subsequent view/frame
void FreeShadowDepthTextures();
// Returns the shadow texture
ITexture* GetShadowTexture( unsigned short h );
// Returns shadow information
const ShadowInfo_t& GetShadowInfo( ClientShadowHandle_t h );
// Renders the shadow texture to screen...
void RenderShadowTexture( int w, int h );
// Sets the shadow direction
virtual void SetShadowDirection( const Vector& dir );
const Vector &GetShadowDirection() const;
// Sets the shadow color
virtual void SetShadowColor( unsigned char r, unsigned char g, unsigned char b );
void GetShadowColor( unsigned char *r, unsigned char *g, unsigned char *b ) const;
// Sets the shadow distance
virtual void SetShadowDistance( float flMaxDistance );
float GetShadowDistance( ) const;
// Sets the screen area at which blobby shadows are always used
virtual void SetShadowBlobbyCutoffArea( float flMinArea );
float GetBlobbyCutoffArea( ) const;
// Set the darkness falloff bias
virtual void SetFalloffBias( ClientShadowHandle_t handle, unsigned char ucBias );
void RestoreRenderState();
// Computes a rough bounding box encompassing the volume of the shadow
void ComputeShadowBBox( IClientRenderable *pRenderable, const Vector &vecAbsCenter, float flRadius, Vector *pAbsMins, Vector *pAbsMaxs );
bool WillParentRenderBlobbyShadow( IClientRenderable *pRenderable );
// Are we the child of a shadow with render-to-texture?
bool ShouldUseParentShadow( IClientRenderable *pRenderable );
void SetShadowsDisabled( bool bDisabled )
{
r_shadows_gamecontrol.SetValue( bDisabled != 1 );
}
private:
enum
{
SHADOW_FLAGS_TEXTURE_DIRTY = (CLIENT_SHADOW_FLAGS_LAST_FLAG << 1),
SHADOW_FLAGS_BRUSH_MODEL = (CLIENT_SHADOW_FLAGS_LAST_FLAG << 2),
SHADOW_FLAGS_USING_LOD_SHADOW = (CLIENT_SHADOW_FLAGS_LAST_FLAG << 3),
SHADOW_FLAGS_LIGHT_WORLD = (CLIENT_SHADOW_FLAGS_LAST_FLAG << 4),
};
struct ClientShadow_t
{
ClientEntityHandle_t m_Entity;
ShadowHandle_t m_ShadowHandle;
ClientLeafShadowHandle_t m_ClientLeafShadowHandle;
unsigned short m_Flags;
VMatrix m_WorldToShadow;
Vector2D m_WorldSize;
Vector m_LastOrigin;
QAngle m_LastAngles;
TextureHandle_t m_ShadowTexture;
CTextureReference m_ShadowDepthTexture;
int m_nRenderFrame;
EHANDLE m_hTargetEntity;
};
private:
// Shadow update functions
void UpdateStudioShadow( IClientRenderable *pRenderable, ClientShadowHandle_t handle );
void UpdateBrushShadow( IClientRenderable *pRenderable, ClientShadowHandle_t handle );
void UpdateShadow( ClientShadowHandle_t handle, bool force );
// Gets the entity whose shadow this shadow will render into
IClientRenderable *GetParentShadowEntity( ClientShadowHandle_t handle );
// Adds the child bounds to the bounding box
void AddChildBounds( matrix3x4_t &matWorldToBBox, IClientRenderable* pParent, Vector &vecMins, Vector &vecMaxs );
// Compute a bounds for the entity + children
void ComputeHierarchicalBounds( IClientRenderable *pRenderable, Vector &vecMins, Vector &vecMaxs );
// Builds matrices transforming from world space to shadow space
void BuildGeneralWorldToShadowMatrix( VMatrix& matWorldToShadow,
const Vector& origin, const Vector& dir, const Vector& xvec, const Vector& yvec );
void BuildWorldToShadowMatrix( VMatrix& matWorldToShadow, const Vector& origin, const Quaternion& quatOrientation );
void BuildPerspectiveWorldToFlashlightMatrix( VMatrix& matWorldToShadow, const FlashlightState_t &flashlightState );
// Update a shadow
void UpdateProjectedTextureInternal( ClientShadowHandle_t handle, bool force );
// Compute the shadow origin and attenuation start distance
float ComputeLocalShadowOrigin( IClientRenderable* pRenderable,
const Vector& mins, const Vector& maxs, const Vector& localShadowDir, float backupFactor, Vector& origin );
// Remove a shadow from the dirty list
void RemoveShadowFromDirtyList( ClientShadowHandle_t handle );
// NOTE: this will ONLY return SHADOWS_NONE, SHADOWS_SIMPLE, or SHADOW_RENDER_TO_TEXTURE.
ShadowType_t GetActualShadowCastType( ClientShadowHandle_t handle ) const;
ShadowType_t GetActualShadowCastType( IClientRenderable *pRenderable ) const;
// Builds a simple blobby shadow
void BuildOrthoShadow( IClientRenderable* pRenderable, ClientShadowHandle_t handle, const Vector& mins, const Vector& maxs);
// Builds a more complex shadow...
void BuildRenderToTextureShadow( IClientRenderable* pRenderable,
ClientShadowHandle_t handle, const Vector& mins, const Vector& maxs );
// Build a projected-texture flashlight
void BuildFlashlight( ClientShadowHandle_t handle );
// Does all the lovely stuff we need to do to have render-to-texture shadows
void SetupRenderToTextureShadow( ClientShadowHandle_t h );
void CleanUpRenderToTextureShadow( ClientShadowHandle_t h );
// Compute the extra shadow planes
void ComputeExtraClipPlanes( IClientRenderable* pRenderable,
ClientShadowHandle_t handle, const Vector* vec,
const Vector& mins, const Vector& maxs, const Vector& localShadowDir );
// Set extra clip planes related to shadows...
void ClearExtraClipPlanes( ClientShadowHandle_t h );
void AddExtraClipPlane( ClientShadowHandle_t h, const Vector& normal, float dist );
// Cull if the origin is on the wrong side of a shadow clip plane....
bool CullReceiver( ClientShadowHandle_t handle, IClientRenderable* pRenderable, IClientRenderable* pSourceRenderable );
bool ComputeSeparatingPlane( IClientRenderable* pRend1, IClientRenderable* pRend2, cplane_t* pPlane );
// Causes all shadows to be re-updated
void UpdateAllShadows();
// One of these gets called with every shadow that potentially will need to re-render
bool DrawRenderToTextureShadow( unsigned short clientShadowHandle, float flArea );
void DrawRenderToTextureShadowLOD( unsigned short clientShadowHandle );
// Draws all children shadows into our own
bool DrawShadowHierarchy( IClientRenderable *pRenderable, const ClientShadow_t &shadow, bool bChild = false );
// Setup stage for threading
bool BuildSetupListForRenderToTextureShadow( unsigned short clientShadowHandle, float flArea );
bool BuildSetupShadowHierarchy( IClientRenderable *pRenderable, const ClientShadow_t &shadow, bool bChild = false );
// Computes + sets the render-to-texture texcoords
void SetRenderToTextureShadowTexCoords( ShadowHandle_t handle, int x, int y, int w, int h );
// Visualization....
void DrawRenderToTextureDebugInfo( IClientRenderable* pRenderable, const Vector& mins, const Vector& maxs );
// Advance frame
void AdvanceFrame();
// Returns renderable-specific shadow info
float GetShadowDistance( IClientRenderable *pRenderable ) const;
const Vector &GetShadowDirection( IClientRenderable *pRenderable ) const;
// Initialize, shutdown render-to-texture shadows
void InitDepthTextureShadows();
void ShutdownDepthTextureShadows();
// Initialize, shutdown render-to-texture shadows
void InitRenderToTextureShadows();
void ShutdownRenderToTextureShadows();
static bool ShadowHandleCompareFunc( const ClientShadowHandle_t& lhs, const ClientShadowHandle_t& rhs )
{
return lhs < rhs;
}
ClientShadowHandle_t CreateProjectedTexture( ClientEntityHandle_t entity, int flags );
// Lock down the usage of a shadow depth texture...must be unlocked use on subsequent views / frames
bool LockShadowDepthTexture( CTextureReference *shadowDepthTexture );
void UnlockAllShadowDepthTextures();
// Set and clear flashlight target renderable
void SetFlashlightTarget( ClientShadowHandle_t shadowHandle, EHANDLE targetEntity );
// Set flashlight light world flag
void SetFlashlightLightWorld( ClientShadowHandle_t shadowHandle, bool bLightWorld );
bool IsFlashlightTarget( ClientShadowHandle_t shadowHandle, IClientRenderable *pRenderable );
// Builds a list of active shadows requiring shadow depth renders
int BuildActiveShadowDepthList( const CViewSetup &viewSetup, int nMaxDepthShadows, ClientShadowHandle_t *pActiveDepthShadows );
// Sets the view's active flashlight render state
void SetViewFlashlightState( int nActiveFlashlightCount, ClientShadowHandle_t* pActiveFlashlights );
private:
Vector m_SimpleShadowDir;
color32 m_AmbientLightColor;
CMaterialReference m_SimpleShadow;
CMaterialReference m_RenderShadow;
CMaterialReference m_RenderModelShadow;
CTextureReference m_DummyColorTexture;
CUtlLinkedList< ClientShadow_t, ClientShadowHandle_t > m_Shadows;
CTextureAllocator m_ShadowAllocator;
bool m_RenderToTextureActive;
bool m_bRenderTargetNeedsClear;
bool m_bUpdatingDirtyShadows;
bool m_bThreaded;
float m_flShadowCastDist;
float m_flMinShadowArea;
CUtlRBTree< ClientShadowHandle_t, unsigned short > m_DirtyShadows;
CUtlVector< ClientShadowHandle_t > m_TransparentShadows;
// These members maintain current state of depth texturing (size and global active state)
// If either changes in a frame, PreRender() will catch it and do the appropriate allocation, deallocation or reallocation
bool m_bDepthTextureActive;
int m_nDepthTextureResolution; // Assume square (height == width)
CUtlVector< CTextureReference > m_DepthTextureCache;
CUtlVector< bool > m_DepthTextureCacheLocks;
int m_nMaxDepthTextureShadows;
friend class CVisibleShadowList;
friend class CVisibleShadowFrustumList;
};
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
static CClientShadowMgr s_ClientShadowMgr;
IClientShadowMgr* g_pClientShadowMgr = &s_ClientShadowMgr;
//-----------------------------------------------------------------------------
// Builds a list of potential shadows that lie within our PVS + view frustum
//-----------------------------------------------------------------------------
struct VisibleShadowInfo_t
{
ClientShadowHandle_t m_hShadow;
float m_flArea;
Vector m_vecAbsCenter;
};
class CVisibleShadowList : public IClientLeafShadowEnum
{
public:
CVisibleShadowList();
int FindShadows( const CViewSetup *pView, int nLeafCount, LeafIndex_t *pLeafList );
int GetVisibleShadowCount() const;
const VisibleShadowInfo_t &GetVisibleShadow( int i ) const;
private:
void EnumShadow( unsigned short clientShadowHandle );
float ComputeScreenArea( const Vector &vecCenter, float r ) const;
void PrioritySort();
CUtlVector<VisibleShadowInfo_t> m_ShadowsInView;
CUtlVector<int> m_PriorityIndex;
};
//-----------------------------------------------------------------------------
// Singleton instances of shadow and shadow frustum lists
//-----------------------------------------------------------------------------
static CVisibleShadowList s_VisibleShadowList;
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CUtlVector<C_BaseAnimating *> s_NPCShadowBoneSetups;
static CUtlVector<C_BaseAnimating *> s_NonNPCShadowBoneSetups;
//-----------------------------------------------------------------------------
// CVisibleShadowList - Constructor and Accessors
//-----------------------------------------------------------------------------
CVisibleShadowList::CVisibleShadowList() : m_ShadowsInView( 0, 64 ), m_PriorityIndex( 0, 64 )
{
}
int CVisibleShadowList::GetVisibleShadowCount() const
{
return m_ShadowsInView.Count();
}
const VisibleShadowInfo_t &CVisibleShadowList::GetVisibleShadow( int i ) const
{
return m_ShadowsInView[m_PriorityIndex[i]];
}
//-----------------------------------------------------------------------------
// CVisibleShadowList - Computes approximate screen area of the shadow
//-----------------------------------------------------------------------------
float CVisibleShadowList::ComputeScreenArea( const Vector &vecCenter, float r ) const
{
CMatRenderContextPtr pRenderContext( materials );
float flScreenDiameter = pRenderContext->ComputePixelDiameterOfSphere( vecCenter, r );
return flScreenDiameter * flScreenDiameter;
}
//-----------------------------------------------------------------------------
// CVisibleShadowList - Visits every shadow in the list of leaves
//-----------------------------------------------------------------------------
void CVisibleShadowList::EnumShadow( unsigned short clientShadowHandle )
{
CClientShadowMgr::ClientShadow_t& shadow = s_ClientShadowMgr.m_Shadows[clientShadowHandle];
// Don't bother if we rendered it this frame, no matter which view it was rendered for
if ( shadow.m_nRenderFrame == gpGlobals->framecount )
return;
// We don't need to bother with it if it's not render-to-texture
if ( s_ClientShadowMgr.GetActualShadowCastType( clientShadowHandle ) != SHADOWS_RENDER_TO_TEXTURE )
return;
// Don't bother with it if the shadow is totally transparent
const ShadowInfo_t &shadowInfo = shadowmgr->GetInfo( shadow.m_ShadowHandle );
if ( shadowInfo.m_FalloffBias == 255 )
return;
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
Assert( pRenderable );
// Don't bother with children of hierarchy; they will be drawn with their parents
if ( s_ClientShadowMgr.ShouldUseParentShadow( pRenderable ) || s_ClientShadowMgr.WillParentRenderBlobbyShadow( pRenderable ) )
return;
// Compute a sphere surrounding the shadow
// FIXME: This doesn't account for children of hierarchy... too bad!
Vector vecAbsCenter;
float flRadius;
s_ClientShadowMgr.ComputeBoundingSphere( pRenderable, vecAbsCenter, flRadius );
// Compute a box surrounding the shadow
Vector vecAbsMins, vecAbsMaxs;
s_ClientShadowMgr.ComputeShadowBBox( pRenderable, vecAbsCenter, flRadius, &vecAbsMins, &vecAbsMaxs );
// FIXME: Add distance check here?
// Make sure it's in the frustum. If it isn't it's not interesting
if (engine->CullBox( vecAbsMins, vecAbsMaxs ))
return;
int i = m_ShadowsInView.AddToTail( );
VisibleShadowInfo_t &info = m_ShadowsInView[i];
info.m_hShadow = clientShadowHandle;
m_ShadowsInView[i].m_flArea = ComputeScreenArea( vecAbsCenter, flRadius );
// Har, har. When water is rendering (or any multipass technique),
// we may well initially render from a viewpoint which doesn't include this shadow.
// That doesn't mean we shouldn't check it again though. Sucks that we need to compute
// the sphere + bbox multiply times though.
shadow.m_nRenderFrame = gpGlobals->framecount;
}
//-----------------------------------------------------------------------------
// CVisibleShadowList - Sort based on screen area/priority
//-----------------------------------------------------------------------------
void CVisibleShadowList::PrioritySort()
{
int nCount = m_ShadowsInView.Count();
m_PriorityIndex.EnsureCapacity( nCount );
m_PriorityIndex.RemoveAll();
int i, j;
for ( i = 0; i < nCount; ++i )
{
m_PriorityIndex.AddToTail(i);
}
for ( i = 0; i < nCount - 1; ++i )
{
int nLargestInd = i;
float flLargestArea = m_ShadowsInView[m_PriorityIndex[i]].m_flArea;
for ( j = i + 1; j < nCount; ++j )
{
int nIndex = m_PriorityIndex[j];
if ( flLargestArea < m_ShadowsInView[nIndex].m_flArea )
{
nLargestInd = j;
flLargestArea = m_ShadowsInView[nIndex].m_flArea;
}
}
::V_swap( m_PriorityIndex[i], m_PriorityIndex[nLargestInd] );
}
}
//-----------------------------------------------------------------------------
// CVisibleShadowList - Main entry point for finding shadows in the leaf list
//-----------------------------------------------------------------------------
int CVisibleShadowList::FindShadows( const CViewSetup *pView, int nLeafCount, LeafIndex_t *pLeafList )
{
VPROF_BUDGET( "CVisibleShadowList::FindShadows", VPROF_BUDGETGROUP_SHADOW_RENDERING );
m_ShadowsInView.RemoveAll();
ClientLeafSystem()->EnumerateShadowsInLeaves( nLeafCount, pLeafList, this );
int nCount = m_ShadowsInView.Count();
if (nCount != 0)
{
// Sort based on screen area/priority
PrioritySort();
}
return nCount;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CClientShadowMgr::CClientShadowMgr() :
m_DirtyShadows( 0, 0, ShadowHandleCompareFunc ),
m_RenderToTextureActive( false ),
m_bDepthTextureActive( false )
{
m_nDepthTextureResolution = r_flashlightdepthres.GetInt();
m_bThreaded = false;
}
//-----------------------------------------------------------------------------
// Changes the shadow direction...
//-----------------------------------------------------------------------------
CON_COMMAND_F( r_shadowdir, "Set shadow direction", FCVAR_CHEAT )
{
if ( args.ArgC() == 1 )
{
Vector dir = s_ClientShadowMgr.GetShadowDirection();
Msg( "%.2f %.2f %.2f\n", dir.x, dir.y, dir.z );
return;
}
if ( args.ArgC() == 4 )
{
Vector dir;
dir.x = atof( args[1] );
dir.y = atof( args[2] );
dir.z = atof( args[3] );
s_ClientShadowMgr.SetShadowDirection(dir);
}
}
CON_COMMAND_F( r_shadowangles, "Set shadow angles", FCVAR_CHEAT )
{
if (args.ArgC() == 1)
{
Vector dir = s_ClientShadowMgr.GetShadowDirection();
QAngle angles;
VectorAngles( dir, angles );
Msg( "%.2f %.2f %.2f\n", angles.x, angles.y, angles.z );
return;
}
if (args.ArgC() == 4)
{
Vector dir;
QAngle angles;
angles.x = atof( args[1] );
angles.y = atof( args[2] );
angles.z = atof( args[3] );
AngleVectors( angles, &dir );
s_ClientShadowMgr.SetShadowDirection(dir);
}
}
CON_COMMAND_F( r_shadowcolor, "Set shadow color", FCVAR_CHEAT )
{
if (args.ArgC() == 1)
{
unsigned char r, g, b;
s_ClientShadowMgr.GetShadowColor( &r, &g, &b );
Msg( "Shadow color %d %d %d\n", r, g, b );
return;
}
if (args.ArgC() == 4)
{
int r = atoi( args[1] );
int g = atoi( args[2] );
int b = atoi( args[3] );
s_ClientShadowMgr.SetShadowColor(r, g, b);
}
}
CON_COMMAND_F( r_shadowdist, "Set shadow distance", FCVAR_CHEAT )
{
if (args.ArgC() == 1)
{
float flDist = s_ClientShadowMgr.GetShadowDistance( );
Msg( "Shadow distance %.2f\n", flDist );
return;
}
if (args.ArgC() == 2)
{
float flDistance = atof( args[1] );
s_ClientShadowMgr.SetShadowDistance( flDistance );
}
}
CON_COMMAND_F( r_shadowblobbycutoff, "some shadow stuff", FCVAR_CHEAT )
{
if (args.ArgC() == 1)
{
float flArea = s_ClientShadowMgr.GetBlobbyCutoffArea( );
Msg( "Cutoff area %.2f\n", flArea );
return;
}
if (args.ArgC() == 2)
{
float flArea = atof( args[1] );
s_ClientShadowMgr.SetShadowBlobbyCutoffArea( flArea );
}
}
static void ShadowRestoreFunc( int nChangeFlags )
{
s_ClientShadowMgr.RestoreRenderState();
}
//-----------------------------------------------------------------------------
// Initialization, shutdown
//-----------------------------------------------------------------------------
bool CClientShadowMgr::Init()
{
m_bRenderTargetNeedsClear = false;
m_SimpleShadow.Init( "decals/simpleshadow", TEXTURE_GROUP_DECAL );
Vector dir( 0.1, 0.1, -1 );
SetShadowDirection(dir);
SetShadowDistance( 50 );
SetShadowBlobbyCutoffArea( 0.005 );
bool bTools = CommandLine()->CheckParm( "-tools" ) != NULL;
m_nMaxDepthTextureShadows = bTools ? 4 : 1; // Just one shadow depth texture in games, more in tools
bool bLowEnd = ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 80 );
if ( !bLowEnd && r_shadowrendertotexture.GetBool() )
{
InitRenderToTextureShadows();
}
// If someone turned shadow depth mapping on but we can't do it, force it off
if ( r_flashlightdepthtexture.GetBool() && !materials->SupportsShadowDepthTextures() )
{
r_flashlightdepthtexture.SetValue( 0 );
ShutdownDepthTextureShadows();
}
if ( !bLowEnd && r_flashlightdepthtexture.GetBool() )
{
InitDepthTextureShadows();
}
materials->AddRestoreFunc( ShadowRestoreFunc );
return true;
}
void CClientShadowMgr::Shutdown()
{
m_SimpleShadow.Shutdown();
m_Shadows.RemoveAll();
ShutdownRenderToTextureShadows();
ShutdownDepthTextureShadows();
materials->RemoveRestoreFunc( ShadowRestoreFunc );
}
//-----------------------------------------------------------------------------
// Initialize, shutdown depth-texture shadows
//-----------------------------------------------------------------------------
void CClientShadowMgr::InitDepthTextureShadows()
{
VPROF_BUDGET( "CClientShadowMgr::InitDepthTextureShadows", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
if( !m_bDepthTextureActive )
{
m_bDepthTextureActive = true;
ImageFormat dstFormat = materials->GetShadowDepthTextureFormat(); // Vendor-dependent depth texture format
#if !defined( _X360 )
ImageFormat nullFormat = materials->GetNullTextureFormat(); // Vendor-dependent null texture format (takes as little memory as possible)
#endif
materials->BeginRenderTargetAllocation();
#if defined( _X360 )
// For the 360, we'll be rendering depth directly into the dummy depth and Resolve()ing to the depth texture.
// only need the dummy surface, don't care about color results
m_DummyColorTexture.InitRenderTargetTexture( r_flashlightdepthres.GetInt(), r_flashlightdepthres.GetInt(), RT_SIZE_OFFSCREEN, IMAGE_FORMAT_BGR565, MATERIAL_RT_DEPTH_SHARED, false, "_rt_ShadowDummy" );
m_DummyColorTexture.InitRenderTargetSurface( r_flashlightdepthres.GetInt(), r_flashlightdepthres.GetInt(), IMAGE_FORMAT_BGR565, true );
#else
m_DummyColorTexture.InitRenderTarget( r_flashlightdepthres.GetInt(), r_flashlightdepthres.GetInt(), RT_SIZE_OFFSCREEN, nullFormat, MATERIAL_RT_DEPTH_NONE, false, "_rt_ShadowDummy" );
#endif
// Create some number of depth-stencil textures
m_DepthTextureCache.Purge();
m_DepthTextureCacheLocks.Purge();
for( int i=0; i < m_nMaxDepthTextureShadows; i++ )
{
CTextureReference depthTex; // Depth-stencil surface
bool bFalse = false;
char strRTName[64];
Q_snprintf( strRTName, ARRAYSIZE( strRTName ), "_rt_ShadowDepthTexture_%d", i );
#if defined( _X360 )
// create a render target to use as a resolve target to get the shared depth buffer
// surface is effectively never used
depthTex.InitRenderTargetTexture( m_nDepthTextureResolution, m_nDepthTextureResolution, RT_SIZE_OFFSCREEN, dstFormat, MATERIAL_RT_DEPTH_NONE, false, strRTName );
depthTex.InitRenderTargetSurface( 1, 1, dstFormat, false );
#else
depthTex.InitRenderTarget( m_nDepthTextureResolution, m_nDepthTextureResolution, RT_SIZE_OFFSCREEN, dstFormat, MATERIAL_RT_DEPTH_NONE, false, strRTName );
#endif
if ( i == 0 )
{
// Shadow may be resized during allocation (due to resolution constraints etc)
m_nDepthTextureResolution = depthTex->GetActualWidth();
r_flashlightdepthres.SetValue( m_nDepthTextureResolution );
}
m_DepthTextureCache.AddToTail( depthTex );
m_DepthTextureCacheLocks.AddToTail( bFalse );
}
materials->EndRenderTargetAllocation();
}
}
void CClientShadowMgr::ShutdownDepthTextureShadows()
{
if( m_bDepthTextureActive )
{
// Shut down the dummy texture
m_DummyColorTexture.Shutdown();
while( m_DepthTextureCache.Count() )
{
m_DepthTextureCache[ m_DepthTextureCache.Count()-1 ].Shutdown();
m_DepthTextureCacheLocks.Remove( m_DepthTextureCache.Count()-1 );
m_DepthTextureCache.Remove( m_DepthTextureCache.Count()-1 );
}
m_bDepthTextureActive = false;
}
}
//-----------------------------------------------------------------------------
// Initialize, shutdown render-to-texture shadows
//-----------------------------------------------------------------------------
void CClientShadowMgr::InitRenderToTextureShadows()
{
if ( !m_RenderToTextureActive )
{
m_RenderToTextureActive = true;
m_RenderShadow.Init( "decals/rendershadow", TEXTURE_GROUP_DECAL );
m_RenderModelShadow.Init( "decals/rendermodelshadow", TEXTURE_GROUP_DECAL );
m_ShadowAllocator.Init();
m_ShadowAllocator.Reset();
m_bRenderTargetNeedsClear = true;
float fr = (float)m_AmbientLightColor.r / 255.0f;
float fg = (float)m_AmbientLightColor.g / 255.0f;
float fb = (float)m_AmbientLightColor.b / 255.0f;
m_RenderShadow->ColorModulate( fr, fg, fb );
m_RenderModelShadow->ColorModulate( fr, fg, fb );
// Iterate over all existing textures and allocate shadow textures
for (ClientShadowHandle_t i = m_Shadows.Head(); i != m_Shadows.InvalidIndex(); i = m_Shadows.Next(i) )
{
ClientShadow_t& shadow = m_Shadows[i];
if ( shadow.m_Flags & SHADOW_FLAGS_USE_RENDER_TO_TEXTURE )
{
SetupRenderToTextureShadow( i );
MarkRenderToTextureShadowDirty( i );
// Switch the material to use render-to-texture shadows
shadowmgr->SetShadowMaterial( shadow.m_ShadowHandle, m_RenderShadow, m_RenderModelShadow, (void*)(uintp)i );
}
}
}
}
void CClientShadowMgr::ShutdownRenderToTextureShadows()
{
if (m_RenderToTextureActive)
{
// Iterate over all existing textures and deallocate shadow textures
for (ClientShadowHandle_t i = m_Shadows.Head(); i != m_Shadows.InvalidIndex(); i = m_Shadows.Next(i) )
{
CleanUpRenderToTextureShadow( i );
// Switch the material to use blobby shadows
ClientShadow_t& shadow = m_Shadows[i];
shadowmgr->SetShadowMaterial( shadow.m_ShadowHandle, m_SimpleShadow, m_SimpleShadow, (void*)CLIENTSHADOW_INVALID_HANDLE );
shadowmgr->SetShadowTexCoord( shadow.m_ShadowHandle, 0, 0, 1, 1 );
ClearExtraClipPlanes( i );
}
m_RenderShadow.Shutdown();
m_RenderModelShadow.Shutdown();
m_ShadowAllocator.DeallocateAllTextures();
m_ShadowAllocator.Shutdown();
// Cause the render target to go away
materials->UncacheUnusedMaterials();
m_RenderToTextureActive = false;
}
}
//-----------------------------------------------------------------------------
// Sets the shadow color
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetShadowColor( unsigned char r, unsigned char g, unsigned char b )
{
float fr = (float)r / 255.0f;
float fg = (float)g / 255.0f;
float fb = (float)b / 255.0f;
// Hook the shadow color into the shadow materials
m_SimpleShadow->ColorModulate( fr, fg, fb );
if (m_RenderToTextureActive)
{
m_RenderShadow->ColorModulate( fr, fg, fb );
m_RenderModelShadow->ColorModulate( fr, fg, fb );
}
m_AmbientLightColor.r = r;
m_AmbientLightColor.g = g;
m_AmbientLightColor.b = b;
}
void CClientShadowMgr::GetShadowColor( unsigned char *r, unsigned char *g, unsigned char *b ) const
{
*r = m_AmbientLightColor.r;
*g = m_AmbientLightColor.g;
*b = m_AmbientLightColor.b;
}
//-----------------------------------------------------------------------------
// Level init... get the shadow color
//-----------------------------------------------------------------------------
void CClientShadowMgr::LevelInitPreEntity()
{
m_bUpdatingDirtyShadows = false;
Vector ambientColor;
engine->GetAmbientLightColor( ambientColor );
ambientColor *= 3;
ambientColor += Vector( 0.3f, 0.3f, 0.3f );
unsigned char r = ambientColor[0] > 1.0 ? 255 : 255 * ambientColor[0];
unsigned char g = ambientColor[1] > 1.0 ? 255 : 255 * ambientColor[1];
unsigned char b = ambientColor[2] > 1.0 ? 255 : 255 * ambientColor[2];
SetShadowColor(r, g, b);
// Set up the texture allocator
if ( m_RenderToTextureActive )
{
m_ShadowAllocator.Reset();
m_bRenderTargetNeedsClear = true;
}
}
//-----------------------------------------------------------------------------
// Clean up all shadows
//-----------------------------------------------------------------------------
void CClientShadowMgr::LevelShutdownPostEntity()
{
// All shadows *should* have been cleaned up when the entities went away
// but, just in case....
Assert( m_Shadows.Count() == 0 );
ClientShadowHandle_t h = m_Shadows.Head();
while (h != CLIENTSHADOW_INVALID_HANDLE)
{
ClientShadowHandle_t next = m_Shadows.Next(h);
DestroyShadow( h );
h = next;
}
// Deallocate all textures
if (m_RenderToTextureActive)
{
m_ShadowAllocator.DeallocateAllTextures();
}
r_shadows_gamecontrol.SetValue( -1 );
}
//-----------------------------------------------------------------------------
// Deals with alt-tab
//-----------------------------------------------------------------------------
void CClientShadowMgr::RestoreRenderState()
{
// Mark all shadows dirty; they need to regenerate their state
ClientShadowHandle_t h;
for ( h = m_Shadows.Head(); h != m_Shadows.InvalidIndex(); h = m_Shadows.Next(h) )
{
m_Shadows[h].m_Flags |= SHADOW_FLAGS_TEXTURE_DIRTY;
}
SetShadowColor( m_AmbientLightColor.r, m_AmbientLightColor.g, m_AmbientLightColor.b );
m_bRenderTargetNeedsClear = true;
}
//-----------------------------------------------------------------------------
// Does all the lovely stuff we need to do to have render-to-texture shadows
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetupRenderToTextureShadow( ClientShadowHandle_t h )
{
// First, compute how much texture memory we want to use.
ClientShadow_t& shadow = m_Shadows[h];
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
if ( !pRenderable )
return;
Vector mins, maxs;
pRenderable->GetShadowRenderBounds( mins, maxs, GetActualShadowCastType( h ) );
// Compute the maximum dimension
Vector size;
VectorSubtract( maxs, mins, size );
float maxSize = MAX( size.x, size.y );
maxSize = MAX( maxSize, size.z );
// Figure out the texture size
// For now, we're going to assume a fixed number of shadow texels
// per shadow-caster size; add in some extra space at the boundary.
int texelCount = TEXEL_SIZE_PER_CASTER_SIZE * maxSize;
// Pick the first power of 2 larger...
int textureSize = 1;
while (textureSize < texelCount)
{
textureSize <<= 1;
}
shadow.m_ShadowTexture = m_ShadowAllocator.AllocateTexture( textureSize, textureSize );
}
void CClientShadowMgr::CleanUpRenderToTextureShadow( ClientShadowHandle_t h )
{
ClientShadow_t& shadow = m_Shadows[h];
if (m_RenderToTextureActive && (shadow.m_Flags & SHADOW_FLAGS_USE_RENDER_TO_TEXTURE))
{
m_ShadowAllocator.DeallocateTexture( shadow.m_ShadowTexture );
shadow.m_ShadowTexture = INVALID_TEXTURE_HANDLE;
}
}
//-----------------------------------------------------------------------------
// Causes all shadows to be re-updated
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateAllShadows()
{
for ( ClientShadowHandle_t i = m_Shadows.Head(); i != m_Shadows.InvalidIndex(); i = m_Shadows.Next(i) )
{
ClientShadow_t& shadow = m_Shadows[i];
// Don't bother with flashlights
if ( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) != 0 )
continue;
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
if ( !pRenderable )
continue;
Assert( pRenderable->GetShadowHandle() == i );
AddToDirtyShadowList( pRenderable, true );
}
}
//-----------------------------------------------------------------------------
// Sets the shadow direction
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetShadowDirection( const Vector& dir )
{
VectorCopy( dir, m_SimpleShadowDir );
VectorNormalize( m_SimpleShadowDir );
if ( m_RenderToTextureActive )
{
UpdateAllShadows();
}
}
const Vector &CClientShadowMgr::GetShadowDirection() const
{
// This will cause blobby shadows to always project straight down
static Vector s_vecDown( 0, 0, -1 );
if ( !m_RenderToTextureActive )
return s_vecDown;
return m_SimpleShadowDir;
}
//-----------------------------------------------------------------------------
// Gets shadow information for a particular renderable
//-----------------------------------------------------------------------------
float CClientShadowMgr::GetShadowDistance( IClientRenderable *pRenderable ) const
{
float flDist = m_flShadowCastDist;
// Allow the renderable to override the default
pRenderable->GetShadowCastDistance( &flDist, GetActualShadowCastType( pRenderable ) );
return flDist;
}
const Vector &CClientShadowMgr::GetShadowDirection( IClientRenderable *pRenderable ) const
{
Vector &vecResult = AllocTempVector();
vecResult = GetShadowDirection();
// Allow the renderable to override the default
pRenderable->GetShadowCastDirection( &vecResult, GetActualShadowCastType( pRenderable ) );
return vecResult;
}
//-----------------------------------------------------------------------------
// Sets the shadow distance
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetShadowDistance( float flMaxDistance )
{
m_flShadowCastDist = flMaxDistance;
UpdateAllShadows();
}
float CClientShadowMgr::GetShadowDistance( ) const
{
return m_flShadowCastDist;
}
//-----------------------------------------------------------------------------
// Sets the screen area at which blobby shadows are always used
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetShadowBlobbyCutoffArea( float flMinArea )
{
m_flMinShadowArea = flMinArea;
}
float CClientShadowMgr::GetBlobbyCutoffArea( ) const
{
return m_flMinShadowArea;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetFalloffBias( ClientShadowHandle_t handle, unsigned char ucBias )
{
shadowmgr->SetFalloffBias( m_Shadows[handle].m_ShadowHandle, ucBias );
}
//-----------------------------------------------------------------------------
// Returns the shadow texture
//-----------------------------------------------------------------------------
ITexture* CClientShadowMgr::GetShadowTexture( unsigned short h )
{
return m_ShadowAllocator.GetTexture();
}
//-----------------------------------------------------------------------------
// Returns information needed by the model proxy
//-----------------------------------------------------------------------------
const ShadowInfo_t& CClientShadowMgr::GetShadowInfo( ClientShadowHandle_t h )
{
return shadowmgr->GetInfo( m_Shadows[h].m_ShadowHandle );
}
//-----------------------------------------------------------------------------
// Renders the shadow texture to screen...
//-----------------------------------------------------------------------------
void CClientShadowMgr::RenderShadowTexture( int w, int h )
{
if (m_RenderToTextureActive)
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( m_RenderShadow );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( w, 0.0f, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( w, h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
}
//-----------------------------------------------------------------------------
// Create/destroy a shadow
//-----------------------------------------------------------------------------
ClientShadowHandle_t CClientShadowMgr::CreateProjectedTexture( ClientEntityHandle_t entity, int flags )
{
// We need to know if it's a brush model for shadows
if( !( flags & SHADOW_FLAGS_FLASHLIGHT ) )
{
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( entity );
if ( !pRenderable )
return m_Shadows.InvalidIndex();
int modelType = modelinfo->GetModelType( pRenderable->GetModel() );
if (modelType == mod_brush)
{
flags |= SHADOW_FLAGS_BRUSH_MODEL;
}
}
ClientShadowHandle_t h = m_Shadows.AddToTail();
ClientShadow_t& shadow = m_Shadows[h];
shadow.m_Entity = entity;
shadow.m_ClientLeafShadowHandle = ClientLeafSystem()->AddShadow( h, flags );
shadow.m_Flags = flags;
shadow.m_nRenderFrame = -1;
shadow.m_LastOrigin.Init( FLT_MAX, FLT_MAX, FLT_MAX );
shadow.m_LastAngles.Init( FLT_MAX, FLT_MAX, FLT_MAX );
Assert( ( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) == 0 ) !=
( ( shadow.m_Flags & SHADOW_FLAGS_SHADOW ) == 0 ) );
// Set up the flags....
IMaterial* pShadowMaterial = m_SimpleShadow;
IMaterial* pShadowModelMaterial = m_SimpleShadow;
void* pShadowProxyData = (void*)CLIENTSHADOW_INVALID_HANDLE;
if ( m_RenderToTextureActive && (flags & SHADOW_FLAGS_USE_RENDER_TO_TEXTURE) )
{
SetupRenderToTextureShadow(h);
pShadowMaterial = m_RenderShadow;
pShadowModelMaterial = m_RenderModelShadow;
pShadowProxyData = (void*)(uintp)h;
}
if( flags & SHADOW_FLAGS_USE_DEPTH_TEXTURE )
{
pShadowMaterial = m_RenderShadow;
pShadowModelMaterial = m_RenderModelShadow;
pShadowProxyData = (void*)(uintp)h;
}
int createShadowFlags;
if( flags & SHADOW_FLAGS_FLASHLIGHT )
{
// don't use SHADOW_CACHE_VERTS with projective lightsources since we expect that they will change every frame.
// FIXME: might want to make it cache optionally if it's an entity light that is static.
createShadowFlags = SHADOW_FLASHLIGHT;
}
else
{
createShadowFlags = SHADOW_CACHE_VERTS;
}
shadow.m_ShadowHandle = shadowmgr->CreateShadowEx( pShadowMaterial, pShadowModelMaterial, pShadowProxyData, createShadowFlags );
return h;
}
ClientShadowHandle_t CClientShadowMgr::CreateFlashlight( const FlashlightState_t &lightState )
{
// We don't really need a model entity handle for a projective light source, so use an invalid one.
static ClientEntityHandle_t invalidHandle = INVALID_CLIENTENTITY_HANDLE;
int shadowFlags = SHADOW_FLAGS_FLASHLIGHT | SHADOW_FLAGS_LIGHT_WORLD;
if( lightState.m_bEnableShadows && r_flashlightdepthtexture.GetBool() )
{
shadowFlags |= SHADOW_FLAGS_USE_DEPTH_TEXTURE;
}
ClientShadowHandle_t shadowHandle = CreateProjectedTexture( invalidHandle, shadowFlags );
UpdateFlashlightState( shadowHandle, lightState );
UpdateProjectedTexture( shadowHandle, true );
return shadowHandle;
}
ClientShadowHandle_t CClientShadowMgr::CreateShadow( ClientEntityHandle_t entity, int flags )
{
// We don't really need a model entity handle for a projective light source, so use an invalid one.
flags &= ~SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK;
flags |= SHADOW_FLAGS_SHADOW | SHADOW_FLAGS_TEXTURE_DIRTY;
ClientShadowHandle_t shadowHandle = CreateProjectedTexture( entity, flags );
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( entity );
if ( pRenderable )
{
Assert( !pRenderable->IsShadowDirty( ) );
pRenderable->MarkShadowDirty( true );
}
// NOTE: We *have* to call the version that takes a shadow handle
// even if we have an entity because this entity hasn't set its shadow handle yet
AddToDirtyShadowList( shadowHandle, true );
return shadowHandle;
}
//-----------------------------------------------------------------------------
// Updates the flashlight direction and re-computes surfaces it should lie on
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateFlashlightState( ClientShadowHandle_t shadowHandle, const FlashlightState_t &flashlightState )
{
VPROF_BUDGET( "CClientShadowMgr::UpdateFlashlightState", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
BuildPerspectiveWorldToFlashlightMatrix( m_Shadows[shadowHandle].m_WorldToShadow, flashlightState );
shadowmgr->UpdateFlashlightState( m_Shadows[shadowHandle].m_ShadowHandle, flashlightState );
}
void CClientShadowMgr::DestroyFlashlight( ClientShadowHandle_t shadowHandle )
{
DestroyShadow( shadowHandle );
}
//-----------------------------------------------------------------------------
// Remove a shadow from the dirty list
//-----------------------------------------------------------------------------
void CClientShadowMgr::RemoveShadowFromDirtyList( ClientShadowHandle_t handle )
{
int idx = m_DirtyShadows.Find( handle );
if ( idx != m_DirtyShadows.InvalidIndex() )
{
// Clean up the shadow update bit.
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( m_Shadows[handle].m_Entity );
if ( pRenderable )
{
pRenderable->MarkShadowDirty( false );
}
m_DirtyShadows.RemoveAt( idx );
}
}
//-----------------------------------------------------------------------------
// Remove a shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::DestroyShadow( ClientShadowHandle_t handle )
{
Assert( m_Shadows.IsValidIndex(handle) );
RemoveShadowFromDirtyList( handle );
shadowmgr->DestroyShadow( m_Shadows[handle].m_ShadowHandle );
ClientLeafSystem()->RemoveShadow( m_Shadows[handle].m_ClientLeafShadowHandle );
CleanUpRenderToTextureShadow( handle );
m_Shadows.Remove(handle);
}
//-----------------------------------------------------------------------------
// Build the worldtotexture matrix
//-----------------------------------------------------------------------------
void CClientShadowMgr::BuildGeneralWorldToShadowMatrix( VMatrix& matWorldToShadow,
const Vector& origin, const Vector& dir, const Vector& xvec, const Vector& yvec )
{
// We're assuming here that xvec + yvec aren't necessary perpendicular
// The shadow->world matrix is pretty simple:
// Just stick the origin in the translation component
// and the vectors in the columns...
matWorldToShadow.SetBasisVectors( xvec, yvec, dir );
matWorldToShadow.SetTranslation( origin );
matWorldToShadow[3][0] = matWorldToShadow[3][1] = matWorldToShadow[3][2] = 0.0f;
matWorldToShadow[3][3] = 1.0f;
// Now do a general inverse to get matWorldToShadow
MatrixInverseGeneral( matWorldToShadow, matWorldToShadow );
}
void CClientShadowMgr::BuildWorldToShadowMatrix( VMatrix& matWorldToShadow, const Vector& origin, const Quaternion& quatOrientation )
{
// The shadow->world matrix is pretty simple:
// Just stick the origin in the translation component
// and the vectors in the columns...
// The inverse of this transposes the rotational component
// and the translational component = - (rotation transpose) * origin
matrix3x4_t matOrientation;
QuaternionMatrix( quatOrientation, matOrientation ); // Convert quat to matrix3x4
PositionMatrix( vec3_origin, matOrientation ); // Zero out translation elements
VMatrix matBasis( matOrientation ); // Convert matrix3x4 to VMatrix
Vector vForward, vLeft, vUp;
matBasis.GetBasisVectors( vForward, vLeft, vUp );
matBasis.SetForward( vLeft ); // Bizarre vector flip inherited from earlier code, WTF?
matBasis.SetLeft( vUp );
matBasis.SetUp( vForward );
matWorldToShadow = matBasis.Transpose(); // Transpose
Vector translation;
Vector3DMultiply( matWorldToShadow, origin, translation );
translation *= -1.0f;
matWorldToShadow.SetTranslation( translation );
// The the bottom row.
matWorldToShadow[3][0] = matWorldToShadow[3][1] = matWorldToShadow[3][2] = 0.0f;
matWorldToShadow[3][3] = 1.0f;
}
void CClientShadowMgr::BuildPerspectiveWorldToFlashlightMatrix( VMatrix& matWorldToShadow, const FlashlightState_t &flashlightState )
{
VPROF_BUDGET( "CClientShadowMgr::BuildPerspectiveWorldToFlashlightMatrix", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
// Buildworld to shadow matrix, then perspective projection and concatenate
VMatrix matWorldToShadowView, matPerspective;
BuildWorldToShadowMatrix( matWorldToShadowView, flashlightState.m_vecLightOrigin,
flashlightState.m_quatOrientation );
MatrixBuildPerspective( matPerspective, flashlightState.m_fHorizontalFOVDegrees,
flashlightState.m_fVerticalFOVDegrees,
flashlightState.m_NearZ, flashlightState.m_FarZ );
MatrixMultiply( matPerspective, matWorldToShadowView, matWorldToShadow );
}
//-----------------------------------------------------------------------------
// Compute the shadow origin and attenuation start distance
//-----------------------------------------------------------------------------
float CClientShadowMgr::ComputeLocalShadowOrigin( IClientRenderable* pRenderable,
const Vector& mins, const Vector& maxs, const Vector& localShadowDir, float backupFactor, Vector& origin )
{
// Compute the centroid of the object...
Vector vecCentroid;
VectorAdd( mins, maxs, vecCentroid );
vecCentroid *= 0.5f;
Vector vecSize;
VectorSubtract( maxs, mins, vecSize );
float flRadius = vecSize.Length() * 0.5f;
// NOTE: The *origin* of the shadow cast is a point on a line passing through
// the centroid of the caster. The direction of this line is the shadow cast direction,
// and the point on that line corresponds to the endpoint of the box that is
// furthest *back* along the shadow direction
// For the first point at which the shadow could possibly start falling off,
// we need to use the point at which the ray described above leaves the
// bounding sphere surrounding the entity. This is necessary because otherwise,
// tall, thin objects would have their shadows appear + disappear as then spun about their origin
// Figure out the corner corresponding to the min + max projection
// along the shadow direction
// We're basically finding the point on the cube that has the largest and smallest
// dot product with the local shadow dir. Then we're taking the dot product
// of that with the localShadowDir. lastly, we're subtracting out the
// centroid projection to give us a distance along the localShadowDir to
// the front and back of the cube along the direction of the ray.
float centroidProjection = DotProduct( vecCentroid, localShadowDir );
float minDist = -centroidProjection;
for (int i = 0; i < 3; ++i)
{
if ( localShadowDir[i] > 0.0f )
{
minDist += localShadowDir[i] * mins[i];
}
else
{
minDist += localShadowDir[i] * maxs[i];
}
}
minDist *= backupFactor;
VectorMA( vecCentroid, minDist, localShadowDir, origin );
return flRadius - minDist;
}
//-----------------------------------------------------------------------------
// Sorts the components of a vector
//-----------------------------------------------------------------------------
static inline void SortAbsVectorComponents( const Vector& src, int* pVecIdx )
{
Vector absVec( fabs(src[0]), fabs(src[1]), fabs(src[2]) );
int maxIdx = (absVec[0] > absVec[1]) ? 0 : 1;
if (absVec[2] > absVec[maxIdx])
{
maxIdx = 2;
}
// always choose something right-handed....
switch( maxIdx )
{
case 0:
pVecIdx[0] = 1;
pVecIdx[1] = 2;
pVecIdx[2] = 0;
break;
case 1:
pVecIdx[0] = 2;
pVecIdx[1] = 0;
pVecIdx[2] = 1;
break;
case 2:
pVecIdx[0] = 0;
pVecIdx[1] = 1;
pVecIdx[2] = 2;
break;
}
}
//-----------------------------------------------------------------------------
// Build the worldtotexture matrix
//-----------------------------------------------------------------------------
static void BuildWorldToTextureMatrix( const VMatrix& matWorldToShadow,
const Vector2D& size, VMatrix& matWorldToTexture )
{
// Build a matrix that maps from shadow space to (u,v) coordinates
VMatrix shadowToUnit;
MatrixBuildScale( shadowToUnit, 1.0f / size.x, 1.0f / size.y, 1.0f );
shadowToUnit[0][3] = shadowToUnit[1][3] = 0.5f;
// Store off the world to (u,v) transformation
MatrixMultiply( shadowToUnit, matWorldToShadow, matWorldToTexture );
}
static void BuildOrthoWorldToShadowMatrix( VMatrix& worldToShadow,
const Vector& origin, const Vector& dir, const Vector& xvec, const Vector& yvec )
{
// This version is faster and assumes dir, xvec, yvec are perpendicular
AssertFloatEquals( DotProduct( dir, xvec ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( dir, yvec ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( xvec, yvec ), 0.0f, 1e-3 );
// The shadow->world matrix is pretty simple:
// Just stick the origin in the translation component
// and the vectors in the columns...
// The inverse of this transposes the rotational component
// and the translational component = - (rotation transpose) * origin
worldToShadow.SetBasisVectors( xvec, yvec, dir );
MatrixTranspose( worldToShadow, worldToShadow );
Vector translation;
Vector3DMultiply( worldToShadow, origin, translation );
translation *= -1.0f;
worldToShadow.SetTranslation( translation );
// The the bottom row.
worldToShadow[3][0] = worldToShadow[3][1] = worldToShadow[3][2] = 0.0f;
worldToShadow[3][3] = 1.0f;
}
//-----------------------------------------------------------------------------
// Set extra clip planes related to shadows...
//-----------------------------------------------------------------------------
void CClientShadowMgr::ClearExtraClipPlanes( ClientShadowHandle_t h )
{
shadowmgr->ClearExtraClipPlanes( m_Shadows[h].m_ShadowHandle );
}
void CClientShadowMgr::AddExtraClipPlane( ClientShadowHandle_t h, const Vector& normal, float dist )
{
shadowmgr->AddExtraClipPlane( m_Shadows[h].m_ShadowHandle, normal, dist );
}
//-----------------------------------------------------------------------------
// Compute the extra shadow planes
//-----------------------------------------------------------------------------
void CClientShadowMgr::ComputeExtraClipPlanes( IClientRenderable* pRenderable,
ClientShadowHandle_t handle, const Vector* vec,
const Vector& mins, const Vector& maxs, const Vector& localShadowDir )
{
// Compute the world-space position of the corner of the bounding box
// that's got the highest dotproduct with the local shadow dir...
Vector origin = pRenderable->GetRenderOrigin( );
float dir[3];
int i;
for ( i = 0; i < 3; ++i )
{
if (localShadowDir[i] < 0.0f)
{
VectorMA( origin, maxs[i], vec[i], origin );
dir[i] = 1;
}
else
{
VectorMA( origin, mins[i], vec[i], origin );
dir[i] = -1;
}
}
// Now that we have it, create 3 planes...
Vector normal;
ClearExtraClipPlanes(handle);
for ( i = 0; i < 3; ++i )
{
VectorMultiply( vec[i], dir[i], normal );
float dist = DotProduct( normal, origin );
AddExtraClipPlane( handle, normal, dist );
}
ClientShadow_t& shadow = m_Shadows[handle];
C_BaseEntity *pEntity = ClientEntityList().GetBaseEntityFromHandle( shadow.m_Entity );
if ( pEntity && pEntity->m_bEnableRenderingClipPlane )
{
normal[ 0 ] = -pEntity->m_fRenderingClipPlane[ 0 ];
normal[ 1 ] = -pEntity->m_fRenderingClipPlane[ 1 ];
normal[ 2 ] = -pEntity->m_fRenderingClipPlane[ 2 ];
AddExtraClipPlane( handle, normal, -pEntity->m_fRenderingClipPlane[ 3 ] - 0.5f );
}
}
inline ShadowType_t CClientShadowMgr::GetActualShadowCastType( ClientShadowHandle_t handle ) const
{
if ( handle == CLIENTSHADOW_INVALID_HANDLE )
{
return SHADOWS_NONE;
}
if ( m_Shadows[handle].m_Flags & SHADOW_FLAGS_USE_RENDER_TO_TEXTURE )
{
return ( m_RenderToTextureActive ? SHADOWS_RENDER_TO_TEXTURE : SHADOWS_SIMPLE );
}
else if( m_Shadows[handle].m_Flags & SHADOW_FLAGS_USE_DEPTH_TEXTURE )
{
return SHADOWS_RENDER_TO_DEPTH_TEXTURE;
}
else
{
return SHADOWS_SIMPLE;
}
}
inline ShadowType_t CClientShadowMgr::GetActualShadowCastType( IClientRenderable *pEnt ) const
{
return GetActualShadowCastType( pEnt->GetShadowHandle() );
}
//-----------------------------------------------------------------------------
// Adds a shadow to all leaves along a ray
//-----------------------------------------------------------------------------
class CShadowLeafEnum : public ISpatialLeafEnumerator
{
public:
bool EnumerateLeaf( int leaf, int context )
{
m_LeafList.AddToTail( leaf );
return true;
}
CUtlVectorFixedGrowable< int, 512 > m_LeafList;
};
//-----------------------------------------------------------------------------
// Builds a list of leaves inside the shadow volume
//-----------------------------------------------------------------------------
static void BuildShadowLeafList( CShadowLeafEnum *pEnum, const Vector& origin,
const Vector& dir, const Vector2D& size, float maxDist )
{
Ray_t ray;
VectorCopy( origin, ray.m_Start );
VectorMultiply( dir, maxDist, ray.m_Delta );
ray.m_StartOffset.Init( 0, 0, 0 );
float flRadius = sqrt( size.x * size.x + size.y * size.y ) * 0.5f;
ray.m_Extents.Init( flRadius, flRadius, flRadius );
ray.m_IsRay = false;
ray.m_IsSwept = true;
ISpatialQuery* pQuery = engine->GetBSPTreeQuery();
pQuery->EnumerateLeavesAlongRay( ray, pEnum, 0 );
}
//-----------------------------------------------------------------------------
// Builds a simple blobby shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::BuildOrthoShadow( IClientRenderable* pRenderable,
ClientShadowHandle_t handle, const Vector& mins, const Vector& maxs)
{
// Get the object's basis
Vector vec[3];
AngleVectors( pRenderable->GetRenderAngles(), &vec[0], &vec[1], &vec[2] );
vec[1] *= -1.0f;
Vector vecShadowDir = GetShadowDirection( pRenderable );
// Project the shadow casting direction into the space of the object
Vector localShadowDir;
localShadowDir[0] = DotProduct( vec[0], vecShadowDir );
localShadowDir[1] = DotProduct( vec[1], vecShadowDir );
localShadowDir[2] = DotProduct( vec[2], vecShadowDir );
// Figure out which vector has the largest component perpendicular
// to the shadow handle...
// Sort by how perpendicular it is
int vecIdx[3];
SortAbsVectorComponents( localShadowDir, vecIdx );
// Here's our shadow basis vectors; namely the ones that are
// most perpendicular to the shadow casting direction
Vector xvec = vec[vecIdx[0]];
Vector yvec = vec[vecIdx[1]];
// Project them into a plane perpendicular to the shadow direction
xvec -= vecShadowDir * DotProduct( vecShadowDir, xvec );
yvec -= vecShadowDir * DotProduct( vecShadowDir, yvec );
VectorNormalize( xvec );
VectorNormalize( yvec );
// Compute the box size
Vector boxSize;
VectorSubtract( maxs, mins, boxSize );
// We project the two longest sides into the vectors perpendicular
// to the projection direction, then add in the projection of the perp direction
Vector2D size( boxSize[vecIdx[0]], boxSize[vecIdx[1]] );
size.x *= fabs( DotProduct( vec[vecIdx[0]], xvec ) );
size.y *= fabs( DotProduct( vec[vecIdx[1]], yvec ) );
// Add the third component into x and y
size.x += boxSize[vecIdx[2]] * fabs( DotProduct( vec[vecIdx[2]], xvec ) );
size.y += boxSize[vecIdx[2]] * fabs( DotProduct( vec[vecIdx[2]], yvec ) );
// Bloat a bit, since the shadow wants to extend outside the model a bit
size.x += 10.0f;
size.y += 10.0f;
// Clamp the minimum size
Vector2DMax( size, Vector2D(10.0f, 10.0f), size );
// Place the origin at the point with min dot product with shadow dir
Vector org;
float falloffStart = ComputeLocalShadowOrigin( pRenderable, mins, maxs, localShadowDir, 2.0f, org );
// Transform the local origin into world coordinates
Vector worldOrigin = pRenderable->GetRenderOrigin( );
VectorMA( worldOrigin, org.x, vec[0], worldOrigin );
VectorMA( worldOrigin, org.y, vec[1], worldOrigin );
VectorMA( worldOrigin, org.z, vec[2], worldOrigin );
// FUNKY: A trick to reduce annoying texelization artifacts!?
float dx = 1.0f / TEXEL_SIZE_PER_CASTER_SIZE;
worldOrigin.x = (int)(worldOrigin.x / dx) * dx;
worldOrigin.y = (int)(worldOrigin.y / dx) * dx;
worldOrigin.z = (int)(worldOrigin.z / dx) * dx;
// NOTE: We gotta use the general matrix because xvec and yvec aren't perp
VMatrix matWorldToShadow, matWorldToTexture;
BuildGeneralWorldToShadowMatrix( m_Shadows[handle].m_WorldToShadow, worldOrigin, vecShadowDir, xvec, yvec );
BuildWorldToTextureMatrix( m_Shadows[handle].m_WorldToShadow, size, matWorldToTexture );
Vector2DCopy( size, m_Shadows[handle].m_WorldSize );
// Compute the falloff attenuation
// Area computation isn't exact since xvec is not perp to yvec, but close enough
// float shadowArea = size.x * size.y;
// The entity may be overriding our shadow cast distance
float flShadowCastDistance = GetShadowDistance( pRenderable );
float maxHeight = flShadowCastDistance + falloffStart; //3.0f * sqrt( shadowArea );
CShadowLeafEnum leafList;
BuildShadowLeafList( &leafList, worldOrigin, vecShadowDir, size, maxHeight );
int nCount = leafList.m_LeafList.Count();
const int *pLeafList = leafList.m_LeafList.Base();
shadowmgr->ProjectShadow( m_Shadows[handle].m_ShadowHandle, worldOrigin,
vecShadowDir, matWorldToTexture, size, nCount, pLeafList, maxHeight, falloffStart, MAX_FALLOFF_AMOUNT, pRenderable->GetRenderOrigin() );
// Compute extra clip planes to prevent poke-thru
// FIXME!!!!!!!!!!!!!! Removing this for now since it seems to mess up the blobby shadows.
// ComputeExtraClipPlanes( pEnt, handle, vec, mins, maxs, localShadowDir );
// Add the shadow to the client leaf system so it correctly marks
// leafs as being affected by a particular shadow
ClientLeafSystem()->ProjectShadow( m_Shadows[handle].m_ClientLeafShadowHandle, nCount, pLeafList );
}
//-----------------------------------------------------------------------------
// Visualization....
//-----------------------------------------------------------------------------
void CClientShadowMgr::DrawRenderToTextureDebugInfo( IClientRenderable* pRenderable, const Vector& mins, const Vector& maxs )
{
if ( !debugoverlay )
return;
// Get the object's basis
Vector vec[3];
AngleVectors( pRenderable->GetRenderAngles(), &vec[0], &vec[1], &vec[2] );
vec[1] *= -1.0f;
Vector vecSize;
VectorSubtract( maxs, mins, vecSize );
Vector vecOrigin = pRenderable->GetRenderOrigin();
Vector start, end, end2;
VectorMA( vecOrigin, mins.x, vec[0], start );
VectorMA( start, mins.y, vec[1], start );
VectorMA( start, mins.z, vec[2], start );
VectorMA( start, vecSize.x, vec[0], end );
VectorMA( end, vecSize.z, vec[2], end2 );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
debugoverlay->AddLineOverlay( end2, end, 255, 0, 0, true, 0.01 );
VectorMA( start, vecSize.y, vec[1], end );
VectorMA( end, vecSize.z, vec[2], end2 );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
debugoverlay->AddLineOverlay( end2, end, 255, 0, 0, true, 0.01 );
VectorMA( start, vecSize.z, vec[2], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
start = end;
VectorMA( start, vecSize.x, vec[0], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
VectorMA( start, vecSize.y, vec[1], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
VectorMA( end, vecSize.x, vec[0], start );
VectorMA( start, -vecSize.x, vec[0], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
VectorMA( start, -vecSize.y, vec[1], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
VectorMA( start, -vecSize.z, vec[2], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
start = end;
VectorMA( start, -vecSize.x, vec[0], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
VectorMA( start, -vecSize.y, vec[1], end );
debugoverlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.01 );
C_BaseEntity *pEnt = pRenderable->GetIClientUnknown()->GetBaseEntity();
if ( pEnt )
{
debugoverlay->AddTextOverlay( vecOrigin, 0, "%d", pEnt->entindex() );
}
else
{
debugoverlay->AddTextOverlay( vecOrigin, 0, "%X", (size_t)pRenderable );
}
}
extern ConVar cl_drawshadowtexture;
extern ConVar cl_shadowtextureoverlaysize;
//-----------------------------------------------------------------------------
// Builds a more complex shadow...
//-----------------------------------------------------------------------------
void CClientShadowMgr::BuildRenderToTextureShadow( IClientRenderable* pRenderable,
ClientShadowHandle_t handle, const Vector& mins, const Vector& maxs)
{
if ( cl_drawshadowtexture.GetInt() )
{
// Red wireframe bounding box around objects whose RTT shadows are being updated that frame
DrawRenderToTextureDebugInfo( pRenderable, mins, maxs );
}
// Get the object's basis
Vector vec[3];
AngleVectors( pRenderable->GetRenderAngles(), &vec[0], &vec[1], &vec[2] );
vec[1] *= -1.0f;
Vector vecShadowDir = GetShadowDirection( pRenderable );
// Debugging aid
// const model_t *pModel = pRenderable->GetModel();
// const char *pDebugName = modelinfo->GetModelName( pModel );
// Project the shadow casting direction into the space of the object
Vector localShadowDir;
localShadowDir[0] = DotProduct( vec[0], vecShadowDir );
localShadowDir[1] = DotProduct( vec[1], vecShadowDir );
localShadowDir[2] = DotProduct( vec[2], vecShadowDir );
// Compute the box size
Vector boxSize;
VectorSubtract( maxs, mins, boxSize );
Vector yvec;
float fProjMax = 0.0f;
for( int i = 0; i != 3; ++i )
{
Vector test = vec[i] - ( vecShadowDir * DotProduct( vecShadowDir, vec[i] ) );
test *= boxSize[i]; //doing after the projection to simplify projection math
float fLengthSqr = test.LengthSqr();
if( fLengthSqr > fProjMax )
{
fProjMax = fLengthSqr;
yvec = test;
}
}
VectorNormalize( yvec );
// Compute the x vector
Vector xvec;
CrossProduct( yvec, vecShadowDir, xvec );
// We project the two longest sides into the vectors perpendicular
// to the projection direction, then add in the projection of the perp direction
Vector2D size;
size.x = boxSize.x * fabs( DotProduct( vec[0], xvec ) ) +
boxSize.y * fabs( DotProduct( vec[1], xvec ) ) +
boxSize.z * fabs( DotProduct( vec[2], xvec ) );
size.y = boxSize.x * fabs( DotProduct( vec[0], yvec ) ) +
boxSize.y * fabs( DotProduct( vec[1], yvec ) ) +
boxSize.z * fabs( DotProduct( vec[2], yvec ) );
size.x += 2.0f * TEXEL_SIZE_PER_CASTER_SIZE;
size.y += 2.0f * TEXEL_SIZE_PER_CASTER_SIZE;
// Place the origin at the point with min dot product with shadow dir
Vector org;
float falloffStart = ComputeLocalShadowOrigin( pRenderable, mins, maxs, localShadowDir, 1.0f, org );
// Transform the local origin into world coordinates
Vector worldOrigin = pRenderable->GetRenderOrigin( );
VectorMA( worldOrigin, org.x, vec[0], worldOrigin );
VectorMA( worldOrigin, org.y, vec[1], worldOrigin );
VectorMA( worldOrigin, org.z, vec[2], worldOrigin );
VMatrix matWorldToTexture;
BuildOrthoWorldToShadowMatrix( m_Shadows[handle].m_WorldToShadow, worldOrigin, vecShadowDir, xvec, yvec );
BuildWorldToTextureMatrix( m_Shadows[handle].m_WorldToShadow, size, matWorldToTexture );
Vector2DCopy( size, m_Shadows[handle].m_WorldSize );
// Compute the falloff attenuation
// Area computation isn't exact since xvec is not perp to yvec, but close enough
// Extra factor of 4 in the maxHeight due to the size being half as big
// float shadowArea = size.x * size.y;
// The entity may be overriding our shadow cast distance
float flShadowCastDistance = GetShadowDistance( pRenderable );
float maxHeight = flShadowCastDistance + falloffStart; //3.0f * sqrt( shadowArea );
CShadowLeafEnum leafList;
BuildShadowLeafList( &leafList, worldOrigin, vecShadowDir, size, maxHeight );
int nCount = leafList.m_LeafList.Count();
const int *pLeafList = leafList.m_LeafList.Base();
shadowmgr->ProjectShadow( m_Shadows[handle].m_ShadowHandle, worldOrigin,
vecShadowDir, matWorldToTexture, size, nCount, pLeafList, maxHeight, falloffStart, MAX_FALLOFF_AMOUNT, pRenderable->GetRenderOrigin() );
// Compute extra clip planes to prevent poke-thru
ComputeExtraClipPlanes( pRenderable, handle, vec, mins, maxs, localShadowDir );
// Add the shadow to the client leaf system so it correctly marks
// leafs as being affected by a particular shadow
ClientLeafSystem()->ProjectShadow( m_Shadows[handle].m_ClientLeafShadowHandle, nCount, pLeafList );
}
static void LineDrawHelper( const Vector &startShadowSpace, const Vector &endShadowSpace,
const VMatrix &shadowToWorld, unsigned char r = 255, unsigned char g = 255,
unsigned char b = 255 )
{
Vector startWorldSpace, endWorldSpace;
Vector3DMultiplyPositionProjective( shadowToWorld, startShadowSpace, startWorldSpace );
Vector3DMultiplyPositionProjective( shadowToWorld, endShadowSpace, endWorldSpace );
if ( debugoverlay )
{
debugoverlay->AddLineOverlay( startWorldSpace + Vector( 0.0f, 0.0f, 1.0f ),
endWorldSpace + Vector( 0.0f, 0.0f, 1.0f ), r, g, b, false, -1 );
}
}
static void DebugDrawFrustum( const Vector &vOrigin, const VMatrix &matWorldToFlashlight )
{
VMatrix flashlightToWorld;
MatrixInverseGeneral( matWorldToFlashlight, flashlightToWorld );
// Draw boundaries of frustum
LineDrawHelper( Vector( 0.0f, 0.0f, 0.0f ), Vector( 0.0f, 0.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 0.0f, 1.0f ), Vector( 0.0f, 1.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 1.0f, 1.0f ), Vector( 0.0f, 1.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 1.0f, 0.0f ), Vector( 0.0f, 0.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 1.0f, 0.0f, 0.0f ), Vector( 1.0f, 0.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 1.0f, 0.0f, 1.0f ), Vector( 1.0f, 1.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 1.0f, 1.0f, 1.0f ), Vector( 1.0f, 1.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 1.0f, 1.0f, 0.0f ), Vector( 1.0f, 0.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 0.0f, 0.0f ), Vector( 1.0f, 0.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 0.0f, 1.0f ), Vector( 1.0f, 0.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 1.0f, 1.0f ), Vector( 1.0f, 1.0f, 1.0f ), flashlightToWorld, 255, 255, 255 );
LineDrawHelper( Vector( 0.0f, 1.0f, 0.0f ), Vector( 1.0f, 1.0f, 0.0f ), flashlightToWorld, 255, 255, 255 );
// Draw RGB triad at front plane
LineDrawHelper( Vector( 0.5f, 0.5f, 0.0f ), Vector( 1.0f, 0.5f, 0.0f ), flashlightToWorld, 255, 0, 0 );
LineDrawHelper( Vector( 0.5f, 0.5f, 0.0f ), Vector( 0.5f, 1.0f, 0.0f ), flashlightToWorld, 0, 255, 0 );
LineDrawHelper( Vector( 0.5f, 0.5f, 0.0f ), Vector( 0.5f, 0.5f, 0.35f ), flashlightToWorld, 0, 0, 255 );
}
//-----------------------------------------------------------------------------
// Builds a list of leaves inside the flashlight volume
//-----------------------------------------------------------------------------
static void BuildFlashlightLeafList( CShadowLeafEnum *pEnum, const VMatrix &worldToShadow )
{
// Use an AABB around the frustum to enumerate leaves.
Vector mins, maxs;
CalculateAABBFromProjectionMatrix( worldToShadow, &mins, &maxs );
ISpatialQuery* pQuery = engine->GetBSPTreeQuery();
pQuery->EnumerateLeavesInBox( mins, maxs, pEnum, 0 );
}
void CClientShadowMgr::BuildFlashlight( ClientShadowHandle_t handle )
{
// For the 360, we just draw flashlights with the main geometry
// and bypass the entire shadow casting system.
ClientShadow_t &shadow = m_Shadows[handle];
if ( IsX360() || r_flashlight_version2.GetInt() )
{
// This will update the matrices, but not do work to add the flashlight to surfaces
shadowmgr->ProjectFlashlight( shadow.m_ShadowHandle, shadow.m_WorldToShadow, 0, NULL );
return;
}
VPROF_BUDGET( "CClientShadowMgr::BuildFlashlight", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
bool bLightModels = r_flashlightmodels.GetBool();
bool bLightSpecificEntity = shadow.m_hTargetEntity.Get() != NULL;
bool bLightWorld = ( shadow.m_Flags & SHADOW_FLAGS_LIGHT_WORLD ) != 0;
int nCount = 0;
const int *pLeafList = 0;
CShadowLeafEnum leafList;
if ( bLightWorld || ( bLightModels && !bLightSpecificEntity ) )
{
BuildFlashlightLeafList( &leafList, shadow.m_WorldToShadow );
nCount = leafList.m_LeafList.Count();
pLeafList = leafList.m_LeafList.Base();
}
if( bLightWorld )
{
shadowmgr->ProjectFlashlight( shadow.m_ShadowHandle, shadow.m_WorldToShadow, nCount, pLeafList );
}
else
{
// This should clear all models and surfaces from this shadow
shadowmgr->EnableShadow( shadow.m_ShadowHandle, false );
shadowmgr->EnableShadow( shadow.m_ShadowHandle, true );
}
if ( !bLightModels )
return;
if ( !bLightSpecificEntity )
{
// Add the shadow to the client leaf system so it correctly marks
// leafs as being affected by a particular shadow
ClientLeafSystem()->ProjectFlashlight( shadow.m_ClientLeafShadowHandle, nCount, pLeafList );
return;
}
// We know what we are focused on, so just add the shadow directly to that receiver
Assert( shadow.m_hTargetEntity->GetModel() );
C_BaseEntity *pChild = shadow.m_hTargetEntity->FirstMoveChild();
while( pChild )
{
int modelType = modelinfo->GetModelType( pChild->GetModel() );
if (modelType == mod_brush)
{
AddShadowToReceiver( handle, pChild, SHADOW_RECEIVER_BRUSH_MODEL );
}
else if ( modelType == mod_studio )
{
AddShadowToReceiver( handle, pChild, SHADOW_RECEIVER_STUDIO_MODEL );
}
pChild = pChild->NextMovePeer();
}
int modelType = modelinfo->GetModelType( shadow.m_hTargetEntity->GetModel() );
if (modelType == mod_brush)
{
AddShadowToReceiver( handle, shadow.m_hTargetEntity, SHADOW_RECEIVER_BRUSH_MODEL );
}
else if ( modelType == mod_studio )
{
AddShadowToReceiver( handle, shadow.m_hTargetEntity, SHADOW_RECEIVER_STUDIO_MODEL );
}
}
//-----------------------------------------------------------------------------
// Adds the child bounds to the bounding box
//-----------------------------------------------------------------------------
void CClientShadowMgr::AddChildBounds( matrix3x4_t &matWorldToBBox, IClientRenderable* pParent, Vector &vecMins, Vector &vecMaxs )
{
Vector vecChildMins, vecChildMaxs;
Vector vecNewChildMins, vecNewChildMaxs;
matrix3x4_t childToBBox;
IClientRenderable *pChild = pParent->FirstShadowChild();
while( pChild )
{
// Transform the child bbox into the space of the main bbox
// FIXME: Optimize this?
if ( GetActualShadowCastType( pChild ) != SHADOWS_NONE)
{
pChild->GetShadowRenderBounds( vecChildMins, vecChildMaxs, SHADOWS_RENDER_TO_TEXTURE );
ConcatTransforms( matWorldToBBox, pChild->RenderableToWorldTransform(), childToBBox );
TransformAABB( childToBBox, vecChildMins, vecChildMaxs, vecNewChildMins, vecNewChildMaxs );
VectorMin( vecMins, vecNewChildMins, vecMins );
VectorMax( vecMaxs, vecNewChildMaxs, vecMaxs );
}
AddChildBounds( matWorldToBBox, pChild, vecMins, vecMaxs );
pChild = pChild->NextShadowPeer();
}
}
//-----------------------------------------------------------------------------
// Compute a bounds for the entity + children
//-----------------------------------------------------------------------------
void CClientShadowMgr::ComputeHierarchicalBounds( IClientRenderable *pRenderable, Vector &vecMins, Vector &vecMaxs )
{
ShadowType_t shadowType = GetActualShadowCastType( pRenderable );
pRenderable->GetShadowRenderBounds( vecMins, vecMaxs, shadowType );
// We could use a good solution for this in the regular PC build, since
// it causes lots of extra bone setups for entities you can't see.
if ( IsPC() )
{
IClientRenderable *pChild = pRenderable->FirstShadowChild();
// Don't recurse down the tree when we hit a blobby shadow
if ( pChild && shadowType != SHADOWS_SIMPLE )
{
matrix3x4_t matWorldToBBox;
MatrixInvert( pRenderable->RenderableToWorldTransform(), matWorldToBBox );
AddChildBounds( matWorldToBBox, pRenderable, vecMins, vecMaxs );
}
}
}
//-----------------------------------------------------------------------------
// Shadow update functions
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateStudioShadow( IClientRenderable *pRenderable, ClientShadowHandle_t handle )
{
if( !( m_Shadows[handle].m_Flags & SHADOW_FLAGS_FLASHLIGHT ) )
{
Vector mins, maxs;
ComputeHierarchicalBounds( pRenderable, mins, maxs );
ShadowType_t shadowType = GetActualShadowCastType( handle );
if ( shadowType != SHADOWS_RENDER_TO_TEXTURE )
{
BuildOrthoShadow( pRenderable, handle, mins, maxs );
}
else
{
BuildRenderToTextureShadow( pRenderable, handle, mins, maxs );
}
}
else
{
BuildFlashlight( handle );
}
}
void CClientShadowMgr::UpdateBrushShadow( IClientRenderable *pRenderable, ClientShadowHandle_t handle )
{
if( !( m_Shadows[handle].m_Flags & SHADOW_FLAGS_FLASHLIGHT ) )
{
// Compute the bounding box in the space of the shadow...
Vector mins, maxs;
ComputeHierarchicalBounds( pRenderable, mins, maxs );
ShadowType_t shadowType = GetActualShadowCastType( handle );
if ( shadowType != SHADOWS_RENDER_TO_TEXTURE )
{
BuildOrthoShadow( pRenderable, handle, mins, maxs );
}
else
{
BuildRenderToTextureShadow( pRenderable, handle, mins, maxs );
}
}
else
{
VPROF_BUDGET( "CClientShadowMgr::UpdateBrushShadow", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
BuildFlashlight( handle );
}
}
#ifdef _DEBUG
static bool s_bBreak = false;
void ShadowBreak_f()
{
s_bBreak = true;
}
static ConCommand r_shadowbreak("r_shadowbreak", ShadowBreak_f);
#endif // _DEBUG
bool CClientShadowMgr::WillParentRenderBlobbyShadow( IClientRenderable *pRenderable )
{
if ( !pRenderable )
return false;
IClientRenderable *pShadowParent = pRenderable->GetShadowParent();
if ( !pShadowParent )
return false;
// If there's *no* shadow casting type, then we want to see if we can render into its parent
ShadowType_t shadowType = GetActualShadowCastType( pShadowParent );
if ( shadowType == SHADOWS_NONE )
return WillParentRenderBlobbyShadow( pShadowParent );
return shadowType == SHADOWS_SIMPLE;
}
//-----------------------------------------------------------------------------
// Are we the child of a shadow with render-to-texture?
//-----------------------------------------------------------------------------
bool CClientShadowMgr::ShouldUseParentShadow( IClientRenderable *pRenderable )
{
if ( !pRenderable )
return false;
IClientRenderable *pShadowParent = pRenderable->GetShadowParent();
if ( !pShadowParent )
return false;
// Can't render into the parent if the parent is blobby
ShadowType_t shadowType = GetActualShadowCastType( pShadowParent );
if ( shadowType == SHADOWS_SIMPLE )
return false;
// If there's *no* shadow casting type, then we want to see if we can render into its parent
if ( shadowType == SHADOWS_NONE )
return ShouldUseParentShadow( pShadowParent );
// Here, the parent uses a render-to-texture shadow
return true;
}
//-----------------------------------------------------------------------------
// Before we render any view, make sure all shadows are re-projected vs world
//-----------------------------------------------------------------------------
void CClientShadowMgr::PreRender()
{
VPROF_BUDGET( "CClientShadowMgr::PreRender", VPROF_BUDGETGROUP_SHADOW_RENDERING );
MDLCACHE_CRITICAL_SECTION();
//
// -- Shadow Depth Textures -----------------------
//
{
// VPROF scope
VPROF_BUDGET( "CClientShadowMgr::PreRender", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
// If someone turned shadow depth mapping on but we can't do it, force it off
if ( r_flashlightdepthtexture.GetBool() && !materials->SupportsShadowDepthTextures() )
{
r_flashlightdepthtexture.SetValue( 0 );
ShutdownDepthTextureShadows();
}
bool bDepthTextureActive = r_flashlightdepthtexture.GetBool();
int nDepthTextureResolution = r_flashlightdepthres.GetInt();
// If shadow depth texture size or enable/disable changed, do appropriate deallocation/(re)allocation
if ( ( bDepthTextureActive != m_bDepthTextureActive ) || ( nDepthTextureResolution != m_nDepthTextureResolution ) )
{
// If shadow depth texturing remains on, but resolution changed, shut down and reinitialize depth textures
if ( ( bDepthTextureActive == true ) && ( m_bDepthTextureActive == true ) &&
( nDepthTextureResolution != m_nDepthTextureResolution ) )
{
ShutdownDepthTextureShadows();
InitDepthTextureShadows();
}
else
{
if ( m_bDepthTextureActive && !bDepthTextureActive ) // Turning off shadow depth texturing
{
ShutdownDepthTextureShadows();
}
else if ( bDepthTextureActive && !m_bDepthTextureActive) // Turning on shadow depth mapping
{
InitDepthTextureShadows();
}
}
}
}
//
// -- Render to Texture Shadows -----------------------
//
bool bRenderToTextureActive = r_shadowrendertotexture.GetBool();
if ( bRenderToTextureActive != m_RenderToTextureActive )
{
if ( m_RenderToTextureActive )
{
ShutdownRenderToTextureShadows();
}
else
{
InitRenderToTextureShadows();
}
UpdateAllShadows();
return;
}
m_bUpdatingDirtyShadows = true;
unsigned short i = m_DirtyShadows.FirstInorder();
while ( i != m_DirtyShadows.InvalidIndex() )
{
ClientShadowHandle_t& handle = m_DirtyShadows[ i ];
Assert( m_Shadows.IsValidIndex( handle ) );
UpdateProjectedTextureInternal( handle, false );
i = m_DirtyShadows.NextInorder(i);
}
m_DirtyShadows.RemoveAll();
// Transparent shadows must remain dirty, since they were not re-projected
int nCount = m_TransparentShadows.Count();
for ( i = 0; i < nCount; ++i )
{
m_DirtyShadows.Insert( m_TransparentShadows[i] );
}
m_TransparentShadows.RemoveAll();
m_bUpdatingDirtyShadows = false;
}
//-----------------------------------------------------------------------------
// Gets the entity whose shadow this shadow will render into
//-----------------------------------------------------------------------------
IClientRenderable *CClientShadowMgr::GetParentShadowEntity( ClientShadowHandle_t handle )
{
ClientShadow_t& shadow = m_Shadows[handle];
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
if ( pRenderable )
{
if ( ShouldUseParentShadow( pRenderable ) )
{
IClientRenderable *pParent = pRenderable->GetShadowParent();
while ( GetActualShadowCastType( pParent ) == SHADOWS_NONE )
{
pParent = pParent->GetShadowParent();
Assert( pParent );
}
return pParent;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Marks a shadow as needing re-projection
//-----------------------------------------------------------------------------
void CClientShadowMgr::AddToDirtyShadowList( ClientShadowHandle_t handle, bool bForce )
{
// Don't add to the dirty shadow list while we're iterating over it
// The only way this can happen is if a child is being rendered into a parent
// shadow, and we don't need it to be added to the dirty list in that case.
if ( m_bUpdatingDirtyShadows )
return;
if ( handle == CLIENTSHADOW_INVALID_HANDLE )
return;
Assert( m_DirtyShadows.Find( handle ) == m_DirtyShadows.InvalidIndex() );
m_DirtyShadows.Insert( handle );
// This pretty much guarantees we'll recompute the shadow
if ( bForce )
{
m_Shadows[handle].m_LastAngles.Init( FLT_MAX, FLT_MAX, FLT_MAX );
}
// If we use our parent shadow, then it's dirty too...
IClientRenderable *pParent = GetParentShadowEntity( handle );
if ( pParent )
{
AddToDirtyShadowList( pParent, bForce );
}
}
//-----------------------------------------------------------------------------
// Marks a shadow as needing re-projection
//-----------------------------------------------------------------------------
void CClientShadowMgr::AddToDirtyShadowList( IClientRenderable *pRenderable, bool bForce )
{
// Don't add to the dirty shadow list while we're iterating over it
// The only way this can happen is if a child is being rendered into a parent
// shadow, and we don't need it to be added to the dirty list in that case.
if ( m_bUpdatingDirtyShadows )
return;
// Are we already in the dirty list?
if ( pRenderable->IsShadowDirty( ) )
return;
ClientShadowHandle_t handle = pRenderable->GetShadowHandle();
if ( handle == CLIENTSHADOW_INVALID_HANDLE )
return;
#ifdef _DEBUG
// Make sure everything's consistent
if ( handle != CLIENTSHADOW_INVALID_HANDLE )
{
IClientRenderable *pShadowRenderable = ClientEntityList().GetClientRenderableFromHandle( m_Shadows[handle].m_Entity );
Assert( pRenderable == pShadowRenderable );
}
#endif
pRenderable->MarkShadowDirty( true );
AddToDirtyShadowList( handle, bForce );
}
//-----------------------------------------------------------------------------
// Marks the render-to-texture shadow as needing to be re-rendered
//-----------------------------------------------------------------------------
void CClientShadowMgr::MarkRenderToTextureShadowDirty( ClientShadowHandle_t handle )
{
// Don't add bogus handles!
if (handle != CLIENTSHADOW_INVALID_HANDLE)
{
// Mark the shadow has having a dirty renter-to-texture
ClientShadow_t& shadow = m_Shadows[handle];
shadow.m_Flags |= SHADOW_FLAGS_TEXTURE_DIRTY;
// If we use our parent shadow, then it's dirty too...
IClientRenderable *pParent = GetParentShadowEntity( handle );
if ( pParent )
{
ClientShadowHandle_t parentHandle = pParent->GetShadowHandle();
if ( parentHandle != CLIENTSHADOW_INVALID_HANDLE )
{
m_Shadows[parentHandle].m_Flags |= SHADOW_FLAGS_TEXTURE_DIRTY;
}
}
}
}
//-----------------------------------------------------------------------------
// Update a shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateShadow( ClientShadowHandle_t handle, bool force )
{
ClientShadow_t& shadow = m_Shadows[handle];
// Get the client entity....
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
if ( !pRenderable )
{
// Retire the shadow if the entity is gone
DestroyShadow( handle );
return;
}
// Don't bother if there's no model on the renderable
if ( !pRenderable->GetModel() )
{
pRenderable->MarkShadowDirty( false );
return;
}
// FIXME: NOTE! Because this is called from PreRender, the falloff bias is
// off by a frame. We could move the code in PreRender to occur after world
// list building is done to fix this issue.
// Don't bother with it if the shadow is totally transparent
const ShadowInfo_t &shadowInfo = shadowmgr->GetInfo( shadow.m_ShadowHandle );
if ( shadowInfo.m_FalloffBias == 255 )
{
shadowmgr->EnableShadow( shadow.m_ShadowHandle, false );
m_TransparentShadows.AddToTail( handle );
return;
}
#ifdef _DEBUG
if (s_bBreak)
{
s_bBreak = false;
}
#endif
// Hierarchical children shouldn't be projecting shadows...
// Check to see if it's a child of an entity with a render-to-texture shadow...
if ( ShouldUseParentShadow( pRenderable ) || WillParentRenderBlobbyShadow( pRenderable ) )
{
shadowmgr->EnableShadow( shadow.m_ShadowHandle, false );
pRenderable->MarkShadowDirty( false );
return;
}
shadowmgr->EnableShadow( shadow.m_ShadowHandle, true );
// Figure out if the shadow moved...
// Even though we have dirty bits, some entities
// never clear those dirty bits
const Vector& origin = pRenderable->GetRenderOrigin();
const QAngle& angles = pRenderable->GetRenderAngles();
if (force || (origin != shadow.m_LastOrigin) || (angles != shadow.m_LastAngles))
{
// Store off the new pos/orientation
VectorCopy( origin, shadow.m_LastOrigin );
VectorCopy( angles, shadow.m_LastAngles );
CMatRenderContextPtr pRenderContext( materials );
const model_t *pModel = pRenderable->GetModel();
MaterialFogMode_t fogMode = pRenderContext->GetFogMode();
pRenderContext->FogMode( MATERIAL_FOG_NONE );
switch( modelinfo->GetModelType( pModel ) )
{
case mod_brush:
UpdateBrushShadow( pRenderable, handle );
break;
case mod_studio:
UpdateStudioShadow( pRenderable, handle );
break;
default:
// Shouldn't get here if not a brush or studio
Assert(0);
break;
}
pRenderContext->FogMode( fogMode );
}
// NOTE: We can't do this earlier because pEnt->GetRenderOrigin() can
// provoke a recomputation of render origin, which, for aiments, can cause everything
// to be marked as dirty. So don't clear the flag until this point.
pRenderable->MarkShadowDirty( false );
}
//-----------------------------------------------------------------------------
// Update a shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateProjectedTextureInternal( ClientShadowHandle_t handle, bool force )
{
ClientShadow_t& shadow = m_Shadows[handle];
if( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT )
{
VPROF_BUDGET( "CClientShadowMgr::UpdateProjectedTextureInternal", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
Assert( ( shadow.m_Flags & SHADOW_FLAGS_SHADOW ) == 0 );
ClientShadow_t& shadowClient = m_Shadows[handle];
shadowmgr->EnableShadow( shadowClient.m_ShadowHandle, true );
// FIXME: What's the difference between brush and model shadows for light projectors? Answer: nothing.
UpdateBrushShadow( NULL, handle );
}
else
{
Assert( shadow.m_Flags & SHADOW_FLAGS_SHADOW );
Assert( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) == 0 );
UpdateShadow( handle, force );
}
}
//-----------------------------------------------------------------------------
// Update a shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::UpdateProjectedTexture( ClientShadowHandle_t handle, bool force )
{
VPROF_BUDGET( "CClientShadowMgr::UpdateProjectedTexture", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
if ( handle == CLIENTSHADOW_INVALID_HANDLE )
return;
// NOTE: This can only work for flashlights, since UpdateProjectedTextureInternal
// depends on the falloff offset to cull shadows.
ClientShadow_t &shadow = m_Shadows[ handle ];
if( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) == 0 )
{
Warning( "CClientShadowMgr::UpdateProjectedTexture can only be used with flashlights!\n" );
return;
}
UpdateProjectedTextureInternal( handle, force );
RemoveShadowFromDirtyList( handle );
}
//-----------------------------------------------------------------------------
// Computes bounding sphere
//-----------------------------------------------------------------------------
void CClientShadowMgr::ComputeBoundingSphere( IClientRenderable* pRenderable, Vector& origin, float& radius )
{
Assert( pRenderable );
Vector mins, maxs;
pRenderable->GetShadowRenderBounds( mins, maxs, GetActualShadowCastType( pRenderable ) );
Vector size;
VectorSubtract( maxs, mins, size );
radius = size.Length() * 0.5f;
// Compute centroid (local space)
Vector centroid;
VectorAdd( mins, maxs, centroid );
centroid *= 0.5f;
// Transform centroid into world space
Vector vec[3];
AngleVectors( pRenderable->GetRenderAngles(), &vec[0], &vec[1], &vec[2] );
vec[1] *= -1.0f;
VectorCopy( pRenderable->GetRenderOrigin(), origin );
VectorMA( origin, centroid.x, vec[0], origin );
VectorMA( origin, centroid.y, vec[1], origin );
VectorMA( origin, centroid.z, vec[2], origin );
}
//-----------------------------------------------------------------------------
// Computes a rough AABB encompassing the volume of the shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::ComputeShadowBBox( IClientRenderable *pRenderable, const Vector &vecAbsCenter, float flRadius, Vector *pAbsMins, Vector *pAbsMaxs )
{
// This is *really* rough. Basically we simply determine the
// maximum shadow casting length and extrude the box by that distance
Vector vecShadowDir = GetShadowDirection( pRenderable );
for (int i = 0; i < 3; ++i)
{
float flShadowCastDistance = GetShadowDistance( pRenderable );
float flDist = flShadowCastDistance * vecShadowDir[i];
if (vecShadowDir[i] < 0)
{
(*pAbsMins)[i] = vecAbsCenter[i] - flRadius + flDist;
(*pAbsMaxs)[i] = vecAbsCenter[i] + flRadius;
}
else
{
(*pAbsMins)[i] = vecAbsCenter[i] - flRadius;
(*pAbsMaxs)[i] = vecAbsCenter[i] + flRadius + flDist;
}
}
}
//-----------------------------------------------------------------------------
// Compute a separating axis...
//-----------------------------------------------------------------------------
bool CClientShadowMgr::ComputeSeparatingPlane( IClientRenderable* pRend1, IClientRenderable* pRend2, cplane_t* pPlane )
{
Vector min1, max1, min2, max2;
pRend1->GetShadowRenderBounds( min1, max1, GetActualShadowCastType( pRend1 ) );
pRend2->GetShadowRenderBounds( min2, max2, GetActualShadowCastType( pRend2 ) );
return ::ComputeSeparatingPlane(
pRend1->GetRenderOrigin(), pRend1->GetRenderAngles(), min1, max1,
pRend2->GetRenderOrigin(), pRend2->GetRenderAngles(), min2, max2,
3.0f, pPlane );
}
//-----------------------------------------------------------------------------
// Cull shadows based on rough bounding volumes
//-----------------------------------------------------------------------------
bool CClientShadowMgr::CullReceiver( ClientShadowHandle_t handle, IClientRenderable* pRenderable,
IClientRenderable* pSourceRenderable )
{
// check flags here instead and assert !pSourceRenderable
if( m_Shadows[handle].m_Flags & SHADOW_FLAGS_FLASHLIGHT )
{
VPROF_BUDGET( "CClientShadowMgr::CullReceiver", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
Assert( !pSourceRenderable );
const Frustum_t &frustum = shadowmgr->GetFlashlightFrustum( m_Shadows[handle].m_ShadowHandle );
Vector mins, maxs;
pRenderable->GetRenderBoundsWorldspace( mins, maxs );
return R_CullBox( mins, maxs, frustum );
}
Assert( pSourceRenderable );
// Compute a bounding sphere for the renderable
Vector origin;
float radius;
ComputeBoundingSphere( pRenderable, origin, radius );
// Transform the sphere center into the space of the shadow
Vector localOrigin;
const ClientShadow_t& shadow = m_Shadows[handle];
const ShadowInfo_t& info = shadowmgr->GetInfo( shadow.m_ShadowHandle );
Vector3DMultiplyPosition( shadow.m_WorldToShadow, origin, localOrigin );
// Compute a rough bounding box for the shadow (in shadow space)
Vector shadowMin, shadowMax;
shadowMin.Init( -shadow.m_WorldSize.x * 0.5f, -shadow.m_WorldSize.y * 0.5f, 0 );
shadowMax.Init( shadow.m_WorldSize.x * 0.5f, shadow.m_WorldSize.y * 0.5f, info.m_MaxDist );
// If the bounding sphere doesn't intersect with the shadow volume, cull
if (!IsBoxIntersectingSphere( shadowMin, shadowMax, localOrigin, radius ))
return true;
Vector originSource;
float radiusSource;
ComputeBoundingSphere( pSourceRenderable, originSource, radiusSource );
// Fast check for separating plane...
bool foundSeparatingPlane = false;
cplane_t plane;
if (!IsSphereIntersectingSphere( originSource, radiusSource, origin, radius ))
{
foundSeparatingPlane = true;
// the plane normal doesn't need to be normalized...
VectorSubtract( origin, originSource, plane.normal );
}
else
{
foundSeparatingPlane = ComputeSeparatingPlane( pRenderable, pSourceRenderable, &plane );
}
if (foundSeparatingPlane)
{
// Compute which side of the plane the renderable is on..
Vector vecShadowDir = GetShadowDirection( pSourceRenderable );
float shadowDot = DotProduct( vecShadowDir, plane.normal );
float receiverDot = DotProduct( plane.normal, origin );
float sourceDot = DotProduct( plane.normal, originSource );
if (shadowDot > 0.0f)
{
if (receiverDot <= sourceDot)
{
// Vector dest;
// VectorMA( pSourceRenderable->GetRenderOrigin(), 50, plane.normal, dest );
// debugoverlay->AddLineOverlay( pSourceRenderable->GetRenderOrigin(), dest, 255, 255, 0, true, 1.0f );
return true;
}
else
{
// Vector dest;
// VectorMA( pSourceRenderable->GetRenderOrigin(), 50, plane.normal, dest );
// debugoverlay->AddLineOverlay( pSourceRenderable->GetRenderOrigin(), dest, 255, 0, 0, true, 1.0f );
}
}
else
{
if (receiverDot >= sourceDot)
{
// Vector dest;
// VectorMA( pSourceRenderable->GetRenderOrigin(), -50, plane.normal, dest );
// debugoverlay->AddLineOverlay( pSourceRenderable->GetRenderOrigin(), dest, 255, 255, 0, true, 1.0f );
return true;
}
else
{
// Vector dest;
// VectorMA( pSourceRenderable->GetRenderOrigin(), 50, plane.normal, dest );
// debugoverlay->AddLineOverlay( pSourceRenderable->GetRenderOrigin(), dest, 255, 0, 0, true, 1.0f );
}
}
}
// No additional clip planes? ok then it's a valid receiver
/*
if (shadow.m_ClipPlaneCount == 0)
return false;
// Check the additional cull planes
int i;
for ( i = 0; i < shadow.m_ClipPlaneCount; ++i)
{
// Fast sphere cull
if (DotProduct( origin, shadow.m_ClipPlane[i] ) - radius > shadow.m_ClipDist[i])
return true;
}
// More expensive box on plane side cull...
Vector vec[3];
Vector mins, maxs;
cplane_t plane;
AngleVectors( pRenderable->GetRenderAngles(), &vec[0], &vec[1], &vec[2] );
pRenderable->GetBounds( mins, maxs );
for ( i = 0; i < shadow.m_ClipPlaneCount; ++i)
{
// Transform the plane into the space of the receiver
plane.normal.x = DotProduct( vec[0], shadow.m_ClipPlane[i] );
plane.normal.y = DotProduct( vec[1], shadow.m_ClipPlane[i] );
plane.normal.z = DotProduct( vec[2], shadow.m_ClipPlane[i] );
plane.dist = shadow.m_ClipDist[i] - DotProduct( shadow.m_ClipPlane[i], pRenderable->GetRenderOrigin() );
// If the box is on the front side of the plane, we're done.
if (BoxOnPlaneSide2( mins, maxs, &plane, 3.0f ) == 1)
return true;
}
*/
return false;
}
//-----------------------------------------------------------------------------
// deals with shadows being added to shadow receivers
//-----------------------------------------------------------------------------
void CClientShadowMgr::AddShadowToReceiver( ClientShadowHandle_t handle,
IClientRenderable* pRenderable, ShadowReceiver_t type )
{
ClientShadow_t &shadow = m_Shadows[handle];
// Don't add a shadow cast by an object to itself...
IClientRenderable* pSourceRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
// NOTE: if pSourceRenderable == NULL, the source is probably a flashlight since there is no entity.
if (pSourceRenderable == pRenderable)
return;
// Don't bother if this renderable doesn't receive shadows or light from flashlights
if( !pRenderable->ShouldReceiveProjectedTextures( SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) )
return;
// Cull if the origin is on the wrong side of a shadow clip plane....
if ( CullReceiver( handle, pRenderable, pSourceRenderable ) )
return;
// Do different things depending on the receiver type
switch( type )
{
case SHADOW_RECEIVER_BRUSH_MODEL:
if( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT )
{
VPROF_BUDGET( "CClientShadowMgr::AddShadowToReceiver", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
if( (!shadow.m_hTargetEntity) || IsFlashlightTarget( handle, pRenderable ) )
{
shadowmgr->AddShadowToBrushModel( shadow.m_ShadowHandle,
const_cast<model_t*>(pRenderable->GetModel()),
pRenderable->GetRenderOrigin(), pRenderable->GetRenderAngles() );
shadowmgr->AddFlashlightRenderable( shadow.m_ShadowHandle, pRenderable );
}
}
else
{
shadowmgr->AddShadowToBrushModel( shadow.m_ShadowHandle,
const_cast<model_t*>(pRenderable->GetModel()),
pRenderable->GetRenderOrigin(), pRenderable->GetRenderAngles() );
}
break;
case SHADOW_RECEIVER_STATIC_PROP:
// Don't add shadows to props if we're not using render-to-texture
if ( GetActualShadowCastType( handle ) == SHADOWS_RENDER_TO_TEXTURE )
{
// Also don't add them unless an NPC or player casts them..
// They are wickedly expensive!!!
C_BaseEntity *pEnt = pSourceRenderable->GetIClientUnknown()->GetBaseEntity();
if ( pEnt && ( pEnt->GetFlags() & (FL_NPC | FL_CLIENT)) )
{
staticpropmgr->AddShadowToStaticProp( shadow.m_ShadowHandle, pRenderable );
}
}
else if( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT )
{
VPROF_BUDGET( "CClientShadowMgr::AddShadowToReceiver", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
if( (!shadow.m_hTargetEntity) || IsFlashlightTarget( handle, pRenderable ) )
{
staticpropmgr->AddShadowToStaticProp( shadow.m_ShadowHandle, pRenderable );
shadowmgr->AddFlashlightRenderable( shadow.m_ShadowHandle, pRenderable );
}
}
break;
case SHADOW_RECEIVER_STUDIO_MODEL:
if( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT )
{
VPROF_BUDGET( "CClientShadowMgr::AddShadowToReceiver", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
if( (!shadow.m_hTargetEntity) || IsFlashlightTarget( handle, pRenderable ) )
{
pRenderable->CreateModelInstance();
shadowmgr->AddShadowToModel( shadow.m_ShadowHandle, pRenderable->GetModelInstance() );
shadowmgr->AddFlashlightRenderable( shadow.m_ShadowHandle, pRenderable );
}
}
break;
// default:
}
}
//-----------------------------------------------------------------------------
// deals with shadows being added to shadow receivers
//-----------------------------------------------------------------------------
void CClientShadowMgr::RemoveAllShadowsFromReceiver(
IClientRenderable* pRenderable, ShadowReceiver_t type )
{
// Don't bother if this renderable doesn't receive shadows
if ( !pRenderable->ShouldReceiveProjectedTextures( SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) )
return;
// Do different things depending on the receiver type
switch( type )
{
case SHADOW_RECEIVER_BRUSH_MODEL:
{
model_t* pModel = const_cast<model_t*>(pRenderable->GetModel());
shadowmgr->RemoveAllShadowsFromBrushModel( pModel );
}
break;
case SHADOW_RECEIVER_STATIC_PROP:
staticpropmgr->RemoveAllShadowsFromStaticProp(pRenderable);
break;
case SHADOW_RECEIVER_STUDIO_MODEL:
if( pRenderable && pRenderable->GetModelInstance() != MODEL_INSTANCE_INVALID )
{
shadowmgr->RemoveAllShadowsFromModel( pRenderable->GetModelInstance() );
}
break;
// default:
// // FIXME: How do deal with this stuff? Add a method to IClientRenderable?
// C_BaseEntity* pEnt = static_cast<C_BaseEntity*>(pRenderable);
// pEnt->RemoveAllShadows();
}
}
//-----------------------------------------------------------------------------
// Computes + sets the render-to-texture texcoords
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetRenderToTextureShadowTexCoords( ShadowHandle_t handle, int x, int y, int w, int h )
{
// Let the shadow mgr know about the texture coordinates...
// That way it'll be able to batch rendering better.
int textureW, textureH;
m_ShadowAllocator.GetTotalTextureSize( textureW, textureH );
// Go in a half-pixel to avoid blending with neighboring textures..
float u, v, du, dv;
u = ((float)x + 0.5f) / (float)textureW;
v = ((float)y + 0.5f) / (float)textureH;
du = ((float)w - 1) / (float)textureW;
dv = ((float)h - 1) / (float)textureH;
shadowmgr->SetShadowTexCoord( handle, u, v, du, dv );
}
//-----------------------------------------------------------------------------
// Setup all children shadows
//-----------------------------------------------------------------------------
bool CClientShadowMgr::BuildSetupShadowHierarchy( IClientRenderable *pRenderable, const ClientShadow_t &shadow, bool bChild )
{
bool bDrewTexture = false;
// Stop traversing when we hit a blobby shadow
ShadowType_t shadowType = GetActualShadowCastType( pRenderable );
if ( pRenderable && shadowType == SHADOWS_SIMPLE )
return false;
if ( !pRenderable || shadowType != SHADOWS_NONE )
{
bool bDrawModelShadow;
if ( !bChild )
{
bDrawModelShadow = ((shadow.m_Flags & SHADOW_FLAGS_BRUSH_MODEL) == 0);
}
else
{
int nModelType = modelinfo->GetModelType( pRenderable->GetModel() );
bDrawModelShadow = nModelType == mod_studio;
}
if ( bDrawModelShadow )
{
C_BaseEntity *pEntity = pRenderable->GetIClientUnknown()->GetBaseEntity();
if ( pEntity )
{
if ( pEntity->IsNPC() )
{
s_NPCShadowBoneSetups.AddToTail( assert_cast<C_BaseAnimating *>( pEntity ) );
}
else if ( pEntity->GetBaseAnimating() )
{
s_NonNPCShadowBoneSetups.AddToTail( assert_cast<C_BaseAnimating *>( pEntity ) );
}
}
bDrewTexture = true;
}
}
if ( !pRenderable )
return bDrewTexture;
IClientRenderable *pChild;
for ( pChild = pRenderable->FirstShadowChild(); pChild; pChild = pChild->NextShadowPeer() )
{
if ( BuildSetupShadowHierarchy( pChild, shadow, true ) )
{
bDrewTexture = true;
}
}
return bDrewTexture;
}
//-----------------------------------------------------------------------------
// Draws all children shadows into our own
//-----------------------------------------------------------------------------
bool CClientShadowMgr::DrawShadowHierarchy( IClientRenderable *pRenderable, const ClientShadow_t &shadow, bool bChild )
{
bool bDrewTexture = false;
// Stop traversing when we hit a blobby shadow
ShadowType_t shadowType = GetActualShadowCastType( pRenderable );
if ( pRenderable && shadowType == SHADOWS_SIMPLE )
return false;
if ( !pRenderable || shadowType != SHADOWS_NONE )
{
bool bDrawModelShadow;
bool bDrawBrushShadow;
if ( !bChild )
{
bDrawModelShadow = ((shadow.m_Flags & SHADOW_FLAGS_BRUSH_MODEL) == 0);
bDrawBrushShadow = !bDrawModelShadow;
}
else
{
int nModelType = modelinfo->GetModelType( pRenderable->GetModel() );
bDrawModelShadow = nModelType == mod_studio;
bDrawBrushShadow = nModelType == mod_brush;
}
if ( bDrawModelShadow )
{
DrawModelInfo_t info;
matrix3x4_t *pBoneToWorld = modelrender->DrawModelShadowSetup( pRenderable, pRenderable->GetBody(), pRenderable->GetSkin(), &info );
if ( pBoneToWorld )
{
modelrender->DrawModelShadow( pRenderable, info, pBoneToWorld );
}
bDrewTexture = true;
}
else if ( bDrawBrushShadow )
{
render->DrawBrushModelShadow( pRenderable );
bDrewTexture = true;
}
}
if ( !pRenderable )
return bDrewTexture;
IClientRenderable *pChild;
for ( pChild = pRenderable->FirstShadowChild(); pChild; pChild = pChild->NextShadowPeer() )
{
if ( DrawShadowHierarchy( pChild, shadow, true ) )
{
bDrewTexture = true;
}
}
return bDrewTexture;
}
//-----------------------------------------------------------------------------
// This gets called with every shadow that potentially will need to re-render
//-----------------------------------------------------------------------------
bool CClientShadowMgr::BuildSetupListForRenderToTextureShadow( unsigned short clientShadowHandle, float flArea )
{
ClientShadow_t& shadow = m_Shadows[clientShadowHandle];
bool bDirtyTexture = (shadow.m_Flags & SHADOW_FLAGS_TEXTURE_DIRTY) != 0;
bool bNeedsRedraw = m_ShadowAllocator.UseTexture( shadow.m_ShadowTexture, bDirtyTexture, flArea );
if ( bNeedsRedraw || bDirtyTexture )
{
shadow.m_Flags |= SHADOW_FLAGS_TEXTURE_DIRTY;
if ( !m_ShadowAllocator.HasValidTexture( shadow.m_ShadowTexture ) )
return false;
// shadow to be redrawn; for now, we'll always do it.
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
if ( BuildSetupShadowHierarchy( pRenderable, shadow ) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// This gets called with every shadow that potentially will need to re-render
//-----------------------------------------------------------------------------
bool CClientShadowMgr::DrawRenderToTextureShadow( unsigned short clientShadowHandle, float flArea )
{
ClientShadow_t& shadow = m_Shadows[clientShadowHandle];
// If we were previously using the LOD shadow, set the material
bool bPreviouslyUsingLODShadow = ( shadow.m_Flags & SHADOW_FLAGS_USING_LOD_SHADOW ) != 0;
shadow.m_Flags &= ~SHADOW_FLAGS_USING_LOD_SHADOW;
if ( bPreviouslyUsingLODShadow )
{
shadowmgr->SetShadowMaterial( shadow.m_ShadowHandle, m_RenderShadow, m_RenderModelShadow, (void*)(uintp)clientShadowHandle );
}
// Mark texture as being used...
bool bDirtyTexture = (shadow.m_Flags & SHADOW_FLAGS_TEXTURE_DIRTY) != 0;
bool bDrewTexture = false;
bool bNeedsRedraw = ( !m_bThreaded && m_ShadowAllocator.UseTexture( shadow.m_ShadowTexture, bDirtyTexture, flArea ) );
if ( !m_ShadowAllocator.HasValidTexture( shadow.m_ShadowTexture ) )
{
DrawRenderToTextureShadowLOD( clientShadowHandle );
return false;
}
if ( bNeedsRedraw || bDirtyTexture )
{
// shadow to be redrawn; for now, we'll always do it.
IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle( shadow.m_Entity );
CMatRenderContextPtr pRenderContext( materials );
// Sets the viewport state
int x, y, w, h;
m_ShadowAllocator.GetTextureRect( shadow.m_ShadowTexture, x, y, w, h );
pRenderContext->Viewport( IsX360() ? 0 : x, IsX360() ? 0 : y, w, h );
// Clear the selected viewport only (don't need to clear depth)
pRenderContext->ClearBuffers( true, false );
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->LoadMatrix( shadowmgr->GetInfo( shadow.m_ShadowHandle ).m_WorldToShadow );
if ( DrawShadowHierarchy( pRenderable, shadow ) )
{
bDrewTexture = true;
if ( IsX360() )
{
// resolve render target to system memory texture
Rect_t srcRect = { 0, 0, w, h };
Rect_t dstRect = { x, y, w, h };
pRenderContext->CopyRenderTargetToTextureEx( m_ShadowAllocator.GetTexture(), 0, &srcRect, &dstRect );
}
}
else
{
// NOTE: Think the flags reset + texcoord set should only happen in DrawShadowHierarchy
// but it's 2 days before 360 ship.. not going to change this now.
DevMsg( "Didn't draw shadow hierarchy.. bad shadow texcoords probably going to happen..grab Brian!\n" );
}
// Only clear the dirty flag if the caster isn't animating
if ( (shadow.m_Flags & SHADOW_FLAGS_ANIMATING_SOURCE) == 0 )
{
shadow.m_Flags &= ~SHADOW_FLAGS_TEXTURE_DIRTY;
}
SetRenderToTextureShadowTexCoords( shadow.m_ShadowHandle, x, y, w, h );
}
else if ( bPreviouslyUsingLODShadow )
{
// In this case, we were previously using the LOD shadow, but we didn't
// have to reconstitute the texture. In this case, we need to reset the texcoord
int x, y, w, h;
m_ShadowAllocator.GetTextureRect( shadow.m_ShadowTexture, x, y, w, h );
SetRenderToTextureShadowTexCoords( shadow.m_ShadowHandle, x, y, w, h );
}
return bDrewTexture;
}
//-----------------------------------------------------------------------------
// "Draws" the shadow LOD, which really means just set up the blobby shadow
//-----------------------------------------------------------------------------
void CClientShadowMgr::DrawRenderToTextureShadowLOD( unsigned short clientShadowHandle )
{
ClientShadow_t &shadow = m_Shadows[clientShadowHandle];
if ( (shadow.m_Flags & SHADOW_FLAGS_USING_LOD_SHADOW) == 0 )
{
shadowmgr->SetShadowMaterial( shadow.m_ShadowHandle, m_SimpleShadow, m_SimpleShadow, (void*)CLIENTSHADOW_INVALID_HANDLE );
shadowmgr->SetShadowTexCoord( shadow.m_ShadowHandle, 0, 0, 1, 1 );
ClearExtraClipPlanes( clientShadowHandle ); // this was ClearExtraClipPlanes( shadow.m_ShadowHandle ), fix is from Joe Demers
shadow.m_Flags |= SHADOW_FLAGS_USING_LOD_SHADOW;
}
}
//-----------------------------------------------------------------------------
// Advances to the next frame,
//-----------------------------------------------------------------------------
void CClientShadowMgr::AdvanceFrame()
{
// We're starting the next frame
m_ShadowAllocator.AdvanceFrame();
}
//-----------------------------------------------------------------------------
// Re-render shadow depth textures that lie in the leaf list
//-----------------------------------------------------------------------------
int CClientShadowMgr::BuildActiveShadowDepthList( const CViewSetup &viewSetup, int nMaxDepthShadows, ClientShadowHandle_t *pActiveDepthShadows )
{
int nActiveDepthShadowCount = 0;
for ( ClientShadowHandle_t i = m_Shadows.Head(); i != m_Shadows.InvalidIndex(); i = m_Shadows.Next(i) )
{
ClientShadow_t& shadow = m_Shadows[i];
// If this is not a flashlight which should use a shadow depth texture, skip!
if ( ( shadow.m_Flags & SHADOW_FLAGS_USE_DEPTH_TEXTURE ) == 0 )
continue;
const FlashlightState_t& flashlightState = shadowmgr->GetFlashlightState( shadow.m_ShadowHandle );
// Bail if this flashlight doesn't want shadows
if ( !flashlightState.m_bEnableShadows )
continue;
// Calculate an AABB around the shadow frustum
Vector vecAbsMins, vecAbsMaxs;
CalculateAABBFromProjectionMatrix( shadow.m_WorldToShadow, &vecAbsMins, &vecAbsMaxs );
Frustum_t viewFrustum;
GeneratePerspectiveFrustum( viewSetup.origin, viewSetup.angles, viewSetup.zNear, viewSetup.zFar, viewSetup.fov, viewSetup.m_flAspectRatio, viewFrustum );
// FIXME: Could do other sorts of culling here, such as frustum-frustum test, distance etc.
// If it's not in the view frustum, move on
if ( R_CullBox( vecAbsMins, vecAbsMaxs, viewFrustum ) )
{
shadowmgr->SetFlashlightDepthTexture( shadow.m_ShadowHandle, NULL, 0 );
continue;
}
if ( nActiveDepthShadowCount >= nMaxDepthShadows )
{
static bool s_bOverflowWarning = false;
if ( !s_bOverflowWarning )
{
Warning( "Too many depth textures rendered in a single view!\n" );
Assert( 0 );
s_bOverflowWarning = true;
}
shadowmgr->SetFlashlightDepthTexture( shadow.m_ShadowHandle, NULL, 0 );
continue;
}
pActiveDepthShadows[nActiveDepthShadowCount++] = i;
}
return nActiveDepthShadowCount;
}
//-----------------------------------------------------------------------------
// Sets the view's active flashlight render state
//-----------------------------------------------------------------------------
void CClientShadowMgr::SetViewFlashlightState( int nActiveFlashlightCount, ClientShadowHandle_t* pActiveFlashlights )
{
// NOTE: On the 360, we render the entire scene with the flashlight state
// set and don't render flashlights additively in the shadow mgr at a far later time
// because the CPU costs are prohibitive
if ( !IsX360() && !r_flashlight_version2.GetInt() )
return;
Assert( nActiveFlashlightCount<= 1 );
if ( nActiveFlashlightCount > 0 )
{
Assert( ( m_Shadows[ pActiveFlashlights[0] ].m_Flags & SHADOW_FLAGS_FLASHLIGHT ) != 0 );
shadowmgr->SetFlashlightRenderState( pActiveFlashlights[0] );
}
else
{
shadowmgr->SetFlashlightRenderState( SHADOW_HANDLE_INVALID );
}
}
//-----------------------------------------------------------------------------
// Re-render shadow depth textures that lie in the leaf list
//-----------------------------------------------------------------------------
void CClientShadowMgr::ComputeShadowDepthTextures( const CViewSetup &viewSetup )
{
VPROF_BUDGET( "CClientShadowMgr::ComputeShadowDepthTextures", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
CMatRenderContextPtr pRenderContext( materials );
PIXEVENT( pRenderContext, "Shadow Depth Textures" );
// Build list of active render-to-texture shadows
ClientShadowHandle_t pActiveDepthShadows[1024];
int nActiveDepthShadowCount = BuildActiveShadowDepthList( viewSetup, ARRAYSIZE( pActiveDepthShadows ), pActiveDepthShadows );
// Iterate over all existing textures and allocate shadow textures
bool bDebugFrustum = r_flashlightdrawfrustum.GetBool();
for ( int j = 0; j < nActiveDepthShadowCount; ++j )
{
ClientShadow_t& shadow = m_Shadows[ pActiveDepthShadows[j] ];
CTextureReference shadowDepthTexture;
bool bGotShadowDepthTexture = LockShadowDepthTexture( &shadowDepthTexture );
if ( !bGotShadowDepthTexture )
{
// If we don't get one, that means we have too many this frame so bind no depth texture
static int bitchCount = 0;
if( bitchCount < 10 )
{
Warning( "Too many shadow maps this frame!\n" );
bitchCount++;
}
Assert(0);
shadowmgr->SetFlashlightDepthTexture( shadow.m_ShadowHandle, NULL, 0 );
continue;
}
CViewSetup shadowView;
shadowView.m_flAspectRatio = 1.0f;
shadowView.x = shadowView.y = 0;
shadowView.width = shadowDepthTexture->GetActualWidth();
shadowView.height = shadowDepthTexture->GetActualHeight();
shadowView.m_bOrtho = false;
shadowView.m_bDoBloomAndToneMapping = false;
// Copy flashlight parameters
const FlashlightState_t& flashlightState = shadowmgr->GetFlashlightState( shadow.m_ShadowHandle );
shadowView.fov = shadowView.fovViewmodel = flashlightState.m_fHorizontalFOVDegrees;
shadowView.origin = flashlightState.m_vecLightOrigin;
QuaternionAngles( flashlightState.m_quatOrientation, shadowView.angles ); // Convert from Quaternion to QAngle
shadowView.zNear = shadowView.zNearViewmodel = flashlightState.m_NearZ;
shadowView.zFar = shadowView.zFarViewmodel = flashlightState.m_FarZ;
// Can turn on all light frustum overlays or per light with flashlightState parameter...
if ( bDebugFrustum || flashlightState.m_bDrawShadowFrustum )
{
DebugDrawFrustum( shadowView.origin, shadow.m_WorldToShadow );
}
// Set depth bias factors specific to this flashlight
CMatRenderContextPtr pRenderContextMat( materials );
pRenderContextMat->SetShadowDepthBiasFactors( flashlightState.m_flShadowSlopeScaleDepthBias, flashlightState.m_flShadowDepthBias );
// Render to the shadow depth texture with appropriate view
view->UpdateShadowDepthTexture( m_DummyColorTexture, shadowDepthTexture, shadowView );
// Associate the shadow depth texture and stencil bit with the flashlight for use during scene rendering
shadowmgr->SetFlashlightDepthTexture( shadow.m_ShadowHandle, shadowDepthTexture, 0 );
}
SetViewFlashlightState( nActiveDepthShadowCount, pActiveDepthShadows );
}
//-----------------------------------------------------------------------------
// Re-renders all shadow textures for shadow casters that lie in the leaf list
//-----------------------------------------------------------------------------
static void SetupBonesOnBaseAnimating( C_BaseAnimating *&pBaseAnimating )
{
pBaseAnimating->SetupBones( NULL, -1, -1, gpGlobals->curtime );
}
void CClientShadowMgr::ComputeShadowTextures( const CViewSetup &viewShadow, int leafCount, LeafIndex_t* pLeafList )
{
VPROF_BUDGET( "CClientShadowMgr::ComputeShadowTextures", VPROF_BUDGETGROUP_SHADOW_RENDERING );
if ( !m_RenderToTextureActive || (r_shadows.GetInt() == 0) || r_shadows_gamecontrol.GetInt() == 0 )
return;
m_bThreaded = false;//( r_threaded_client_shadow_manager.GetBool() && g_pThreadPool->NumIdleThreads() );
MDLCACHE_CRITICAL_SECTION();
// First grab all shadow textures we may want to render
int nCount = s_VisibleShadowList.FindShadows( &viewShadow, leafCount, pLeafList );
if ( nCount == 0 )
return;
// FIXME: Add heuristics based on distance, etc. to futz with
// the shadow allocator + to select blobby shadows
CMatRenderContextPtr pRenderContext( materials );
PIXEVENT( pRenderContext, "Render-To-Texture Shadows" );
// Clear to white (color unused), black alpha
pRenderContext->ClearColor4ub( 255, 255, 255, 0 );
// No height clip mode please.
MaterialHeightClipMode_t oldHeightClipMode = pRenderContext->GetHeightClipMode();
pRenderContext->SetHeightClipMode( MATERIAL_HEIGHTCLIPMODE_DISABLE );
// No projection matrix (orthographic mode)
// FIXME: Make it work for projective shadows?
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->Scale( 1, -1, 1 );
pRenderContext->Ortho( 0, 0, 1, 1, -9999, 0 );
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PushMatrix();
pRenderContext->PushRenderTargetAndViewport( m_ShadowAllocator.GetTexture() );
if ( !IsX360() && m_bRenderTargetNeedsClear )
{
// don't need to clear absent depth buffer
pRenderContext->ClearBuffers( true, false );
m_bRenderTargetNeedsClear = false;
}
int nMaxShadows = r_shadowmaxrendered.GetInt();
int nModelsRendered = 0;
int i;
if ( m_bThreaded && g_pThreadPool->NumIdleThreads() )
{
s_NPCShadowBoneSetups.RemoveAll();
s_NonNPCShadowBoneSetups.RemoveAll();
for (i = 0; i < nCount; ++i)
{
const VisibleShadowInfo_t &info = s_VisibleShadowList.GetVisibleShadow(i);
if ( nModelsRendered < nMaxShadows )
{
if ( BuildSetupListForRenderToTextureShadow( info.m_hShadow, info.m_flArea ) )
{
++nModelsRendered;
}
}
}
ParallelProcess( "NPCShadowBoneSetups", s_NPCShadowBoneSetups.Base(), s_NPCShadowBoneSetups.Count(), &SetupBonesOnBaseAnimating );
ParallelProcess( "NonNPCShadowBoneSetups", s_NonNPCShadowBoneSetups.Base(), s_NonNPCShadowBoneSetups.Count(), &SetupBonesOnBaseAnimating );
nModelsRendered = 0;
}
for (i = 0; i < nCount; ++i)
{
const VisibleShadowInfo_t &info = s_VisibleShadowList.GetVisibleShadow(i);
if ( nModelsRendered < nMaxShadows )
{
if ( DrawRenderToTextureShadow( info.m_hShadow, info.m_flArea ) )
{
++nModelsRendered;
}
}
else
{
DrawRenderToTextureShadowLOD( info.m_hShadow );
}
}
// Render to the backbuffer again
pRenderContext->PopRenderTargetAndViewport();
// Restore the matrices
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PopMatrix();
pRenderContext->SetHeightClipMode( oldHeightClipMode );
pRenderContext->SetHeightClipMode( oldHeightClipMode );
// Restore the clear color
pRenderContext->ClearColor3ub( 0, 0, 0 );
}
//-------------------------------------------------------------------------------------------------------
// Lock down the usage of a shadow depth texture...must be unlocked for use on subsequent views / frames
//-------------------------------------------------------------------------------------------------------
bool CClientShadowMgr::LockShadowDepthTexture( CTextureReference *shadowDepthTexture )
{
for ( int i=0; i < m_DepthTextureCache.Count(); i++ ) // Search for cached shadow depth texture
{
if ( m_DepthTextureCacheLocks[i] == false ) // If a free one is found
{
*shadowDepthTexture = m_DepthTextureCache[i];
m_DepthTextureCacheLocks[i] = true;
return true;
}
}
return false; // Didn't find it...
}
//------------------------------------------------------------------
// Unlock shadow depth texture for use on subsequent views / frames
//------------------------------------------------------------------
void CClientShadowMgr::UnlockAllShadowDepthTextures()
{
for (int i=0; i< m_DepthTextureCache.Count(); i++ )
{
m_DepthTextureCacheLocks[i] = false;
}
SetViewFlashlightState( 0, NULL );
}
void CClientShadowMgr::SetFlashlightTarget( ClientShadowHandle_t shadowHandle, EHANDLE targetEntity )
{
Assert( m_Shadows.IsValidIndex( shadowHandle ) );
CClientShadowMgr::ClientShadow_t &shadow = m_Shadows[ shadowHandle ];
if( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) == 0 )
return;
// shadow.m_pTargetRenderable = pRenderable;
shadow.m_hTargetEntity = targetEntity;
}
void CClientShadowMgr::SetFlashlightLightWorld( ClientShadowHandle_t shadowHandle, bool bLightWorld )
{
Assert( m_Shadows.IsValidIndex( shadowHandle ) );
ClientShadow_t &shadow = m_Shadows[ shadowHandle ];
if( ( shadow.m_Flags & SHADOW_FLAGS_FLASHLIGHT ) == 0 )
return;
if ( bLightWorld )
{
shadow.m_Flags |= SHADOW_FLAGS_LIGHT_WORLD;
}
else
{
shadow.m_Flags &= ~SHADOW_FLAGS_LIGHT_WORLD;
}
}
bool CClientShadowMgr::IsFlashlightTarget( ClientShadowHandle_t shadowHandle, IClientRenderable *pRenderable )
{
ClientShadow_t &shadow = m_Shadows[ shadowHandle ];
if( shadow.m_hTargetEntity->GetClientRenderable() == pRenderable )
return true;
C_BaseEntity *pChild = shadow.m_hTargetEntity->FirstMoveChild();
while( pChild )
{
if( pChild->GetClientRenderable()==pRenderable )
return true;
pChild = pChild->NextMovePeer();
}
return false;
}
//-----------------------------------------------------------------------------
// A material proxy that resets the base texture to use the rendered shadow
//-----------------------------------------------------------------------------
class CShadowProxy : public IMaterialProxy
{
public:
CShadowProxy();
virtual ~CShadowProxy();
virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
virtual void OnBind( void *pProxyData );
virtual void Release( void ) { delete this; }
virtual IMaterial *GetMaterial();
private:
IMaterialVar* m_BaseTextureVar;
};
CShadowProxy::CShadowProxy()
{
m_BaseTextureVar = NULL;
}
CShadowProxy::~CShadowProxy()
{
}
bool CShadowProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
bool foundVar;
m_BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
return foundVar;
}
void CShadowProxy::OnBind( void *pProxyData )
{
unsigned short clientShadowHandle = ( unsigned short )(int)pProxyData&0xffff;
ITexture* pTex = s_ClientShadowMgr.GetShadowTexture( clientShadowHandle );
m_BaseTextureVar->SetTextureValue( pTex );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
IMaterial *CShadowProxy::GetMaterial()
{
return m_BaseTextureVar->GetOwningMaterial();
}
EXPOSE_INTERFACE( CShadowProxy, IMaterialProxy, "Shadow" IMATERIAL_PROXY_INTERFACE_VERSION );
//-----------------------------------------------------------------------------
// A material proxy that resets the base texture to use the rendered shadow
//-----------------------------------------------------------------------------
class CShadowModelProxy : public IMaterialProxy
{
public:
CShadowModelProxy();
virtual ~CShadowModelProxy();
virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
virtual void OnBind( void *pProxyData );
virtual void Release( void ) { delete this; }
virtual IMaterial *GetMaterial();
private:
IMaterialVar* m_BaseTextureVar;
IMaterialVar* m_BaseTextureOffsetVar;
IMaterialVar* m_BaseTextureScaleVar;
IMaterialVar* m_BaseTextureMatrixVar;
IMaterialVar* m_FalloffOffsetVar;
IMaterialVar* m_FalloffDistanceVar;
IMaterialVar* m_FalloffAmountVar;
};
CShadowModelProxy::CShadowModelProxy()
{
m_BaseTextureVar = NULL;
m_BaseTextureOffsetVar = NULL;
m_BaseTextureScaleVar = NULL;
m_BaseTextureMatrixVar = NULL;
m_FalloffOffsetVar = NULL;
m_FalloffDistanceVar = NULL;
m_FalloffAmountVar = NULL;
}
CShadowModelProxy::~CShadowModelProxy()
{
}
bool CShadowModelProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
bool foundVar;
m_BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
if (!foundVar)
return false;
m_BaseTextureOffsetVar = pMaterial->FindVar( "$basetextureoffset", &foundVar, false );
if (!foundVar)
return false;
m_BaseTextureScaleVar = pMaterial->FindVar( "$basetexturescale", &foundVar, false );
if (!foundVar)
return false;
m_BaseTextureMatrixVar = pMaterial->FindVar( "$basetexturetransform", &foundVar, false );
if (!foundVar)
return false;
m_FalloffOffsetVar = pMaterial->FindVar( "$falloffoffset", &foundVar, false );
if (!foundVar)
return false;
m_FalloffDistanceVar = pMaterial->FindVar( "$falloffdistance", &foundVar, false );
if (!foundVar)
return false;
m_FalloffAmountVar = pMaterial->FindVar( "$falloffamount", &foundVar, false );
return foundVar;
}
void CShadowModelProxy::OnBind( void *pProxyData )
{
unsigned short clientShadowHandle = ( unsigned short )((int)pProxyData&0xffff);
ITexture* pTex = s_ClientShadowMgr.GetShadowTexture( clientShadowHandle );
m_BaseTextureVar->SetTextureValue( pTex );
const ShadowInfo_t& info = s_ClientShadowMgr.GetShadowInfo( clientShadowHandle );
m_BaseTextureMatrixVar->SetMatrixValue( info.m_WorldToShadow );
m_BaseTextureOffsetVar->SetVecValue( info.m_TexOrigin.Base(), 2 );
m_BaseTextureScaleVar->SetVecValue( info.m_TexSize.Base(), 2 );
m_FalloffOffsetVar->SetFloatValue( info.m_FalloffOffset );
m_FalloffDistanceVar->SetFloatValue( info.m_MaxDist );
m_FalloffAmountVar->SetFloatValue( info.m_FalloffAmount );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
IMaterial *CShadowModelProxy::GetMaterial()
{
return m_BaseTextureVar->GetOwningMaterial();
}
EXPOSE_INTERFACE( CShadowModelProxy, IMaterialProxy, "ShadowModel" IMATERIAL_PROXY_INTERFACE_VERSION );