542 lines
19 KiB
C++
542 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "r_studiolight.h"
|
|
#include "studiorender.h"
|
|
#include "studiorendercontext.h"
|
|
#include "studio.h"
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
|
#include "mathlib/vector.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include <float.h>
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
void R_WorldLightDelta( const LightDesc_t *wl, const Vector& org, Vector& delta );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies lighting state
|
|
//-----------------------------------------------------------------------------
|
|
int CopyLocalLightingState( int nMaxLights, LightDesc_t *pDest, int nLightCount, const LightDesc_t *pSrc )
|
|
{
|
|
// ensure we write within array bounds
|
|
if ( nLightCount > nMaxLights )
|
|
{
|
|
nLightCount = nMaxLights;
|
|
}
|
|
|
|
for( int i = 0; i < nLightCount; i++ )
|
|
{
|
|
LightDesc_t *pLight = &pDest[i];
|
|
memcpy( pLight, &pSrc[i], sizeof( LightDesc_t ) );
|
|
pLight->m_Flags = 0;
|
|
if( pLight->m_Attenuation0 != 0.0f )
|
|
{
|
|
pLight->m_Flags |= LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0;
|
|
}
|
|
if( pLight->m_Attenuation1 != 0.0f )
|
|
{
|
|
pLight->m_Flags |= LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1;
|
|
}
|
|
if( pLight->m_Attenuation2 != 0.0f )
|
|
{
|
|
pLight->m_Flags |= LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2;
|
|
}
|
|
}
|
|
|
|
return nLightCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the ambient term
|
|
//-----------------------------------------------------------------------------
|
|
void R_LightAmbient_4D( const Vector& normal, Vector4D* pLightBoxColor, Vector &lv )
|
|
{
|
|
VectorScale( normal[0] > 0.f ? pLightBoxColor[0].AsVector3D() : pLightBoxColor[1].AsVector3D(), normal[0]*normal[0], lv );
|
|
VectorMA( lv, normal[1]*normal[1], normal[1] > 0.f ? pLightBoxColor[2].AsVector3D() : pLightBoxColor[3].AsVector3D(), lv );
|
|
VectorMA( lv, normal[2]*normal[2], normal[2] > 0.f ? pLightBoxColor[4].AsVector3D() : pLightBoxColor[5].AsVector3D(), lv );
|
|
}
|
|
|
|
#if defined( _WIN32 ) && !defined( _X360 )
|
|
void R_LightAmbient_4D( const FourVectors& normal, Vector4D* pLightBoxColor, FourVectors &lv )
|
|
{
|
|
// VPROF( "R_LightAmbient" );
|
|
|
|
// !!speed!! compute ambient color cube in sse format
|
|
static fltx4 FourZeros={0.,0.,0.,.0};
|
|
|
|
// find the contributions from each axis
|
|
fltx4 NegMask=CmpLtSIMD(normal.x,FourZeros);
|
|
fltx4 ColorSelect0=ReplicateX4(pLightBoxColor[0].AsVector3D().x);
|
|
fltx4 ColorSelect1=ReplicateX4(pLightBoxColor[1].AsVector3D().x);
|
|
fltx4 DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
fltx4 NormCompSquared=MulSIMD(normal.x,normal.x);
|
|
lv.x=MulSIMD(DirectionalColor,NormCompSquared);
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[0].AsVector3D().y);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[1].AsVector3D().y);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.y=MulSIMD(DirectionalColor,NormCompSquared);
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[0].AsVector3D().z);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[1].AsVector3D().z);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.z=MulSIMD(DirectionalColor,NormCompSquared);
|
|
|
|
NegMask=CmpLtSIMD(normal.y,FourZeros);
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[2].AsVector3D().x);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[3].AsVector3D().x);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
NormCompSquared=MulSIMD(normal.y,normal.y);
|
|
lv.x=AddSIMD(lv.x,MulSIMD(DirectionalColor,NormCompSquared));
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[2].AsVector3D().y);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[3].AsVector3D().y);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.y=AddSIMD(lv.y,MulSIMD(DirectionalColor,NormCompSquared));
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[2].AsVector3D().z);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[3].AsVector3D().z);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.z=AddSIMD(lv.z,MulSIMD(DirectionalColor,NormCompSquared));
|
|
|
|
NegMask=CmpLtSIMD(normal.z,FourZeros);
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[4].AsVector3D().x);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[5].AsVector3D().x);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
NormCompSquared=MulSIMD(normal.z,normal.z);
|
|
lv.x=AddSIMD(lv.x,MulSIMD(DirectionalColor,NormCompSquared));
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[4].AsVector3D().y);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[5].AsVector3D().y);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.y=AddSIMD(lv.y,MulSIMD(DirectionalColor,NormCompSquared));
|
|
ColorSelect0=ReplicateX4(pLightBoxColor[4].AsVector3D().z);
|
|
ColorSelect1=ReplicateX4(pLightBoxColor[5].AsVector3D().z);
|
|
DirectionalColor=OrSIMD(AndSIMD(ColorSelect1,NegMask),AndNotSIMD(NegMask,ColorSelect0));
|
|
lv.z=AddSIMD(lv.z,MulSIMD(DirectionalColor,NormCompSquared));
|
|
}
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the ambient term, parameters are 3D Vectors for optimization
|
|
//-----------------------------------------------------------------------------
|
|
void R_LightAmbient_3D( const Vector& normal, const Vector* pLightBoxColor, Vector &lv )
|
|
{
|
|
VectorScale( normal[0] > 0.f ? pLightBoxColor[0] : pLightBoxColor[1], normal[0]*normal[0], lv );
|
|
VectorMA( lv, normal[1]*normal[1], normal[1] > 0.f ? pLightBoxColor[2] : pLightBoxColor[3], lv );
|
|
VectorMA( lv, normal[2]*normal[2], normal[2] > 0.f ? pLightBoxColor[4] : pLightBoxColor[5], lv );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set up light[i].dot, light[i].falloff, and light[i].delta for all lights given
|
|
// a vertex position "vert".
|
|
//-----------------------------------------------------------------------------
|
|
void R_LightStrengthWorld( const Vector& vert, int lightcount, LightDesc_t* pDesc, lightpos_t *light )
|
|
{
|
|
// VPROF( "R_LightStrengthWorld" );
|
|
|
|
// NJS: note to self, maybe switch here based on lightcount, so multiple squareroots can be done simeltaneously?
|
|
for ( int i = 0; i < lightcount; i++)
|
|
{
|
|
R_WorldLightDelta( &pDesc[i], vert, light[i].delta );
|
|
light[i].falloff = R_WorldLightDistanceFalloff( &pDesc[i], light[i].delta );
|
|
|
|
VectorNormalizeFast( light[i].delta );
|
|
light[i].dot = DotProduct( light[i].delta, pDesc[i].m_Direction );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Calculate the delta between a light and position
|
|
//-----------------------------------------------------------------------------
|
|
void R_WorldLightDelta( const LightDesc_t *wl, const Vector& org, Vector& delta )
|
|
{
|
|
switch (wl->m_Type)
|
|
{
|
|
case MATERIAL_LIGHT_POINT:
|
|
case MATERIAL_LIGHT_SPOT:
|
|
VectorSubtract( wl->m_Position, org, delta );
|
|
break;
|
|
|
|
case MATERIAL_LIGHT_DIRECTIONAL:
|
|
VectorMultiply( wl->m_Direction, -1, delta );
|
|
break;
|
|
|
|
default:
|
|
// Bug: need to return an error
|
|
Assert( 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//#define NO_AMBIENT_CUBE 1
|
|
|
|
// TODO: cone clipping calc's wont work for boxlight since the player asks for a single point. Not sure what the volume is.
|
|
TEMPLATE_FUNCTION_TABLE( void, R_LightEffectsWorldFunctionTable, ( const LightDesc_t* pLightDesc, const lightpos_t *light, const Vector& normal, Vector &dest ), 256 )
|
|
{
|
|
enum
|
|
{
|
|
LightType1 = ( nArgument & 0xC0 ) >> 6,
|
|
LightType2 = ( nArgument & 0x30 ) >> 4,
|
|
LightType3 = ( nArgument & 0x0C ) >> 2,
|
|
LightType4 = ( nArgument & 0x03 )
|
|
};
|
|
|
|
// VPROF( "R_LightEffectsWorld" );
|
|
|
|
#ifdef NO_AMBIENT_CUBE
|
|
dest[0] = dest[1] = dest[2] = 0.0f;
|
|
#endif
|
|
|
|
// FIXME: lighting effects for normal and position are independent!
|
|
// FIXME: these can be pre-calculated per normal
|
|
if( (LightType_t)LightType1 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[0].falloff * CWorldLightAngleWrapper<LightType1>::WorldLightAngle( &pLightDesc[0], pLightDesc[0].m_Direction, normal, light[0].delta );
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[0].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType2 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[1].falloff * CWorldLightAngleWrapper<LightType2>::WorldLightAngle( &pLightDesc[1], pLightDesc[1].m_Direction, normal, light[1].delta );
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[1].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType3 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[2].falloff * CWorldLightAngleWrapper<LightType3>::WorldLightAngle( &pLightDesc[2], pLightDesc[2].m_Direction, normal, light[2].delta );
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[2].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType4 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[3].falloff * CWorldLightAngleWrapper<LightType4>::WorldLightAngle( &pLightDesc[3], pLightDesc[3].m_Direction, normal, light[3].delta );
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[3].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
}
|
|
|
|
TEMPLATE_FUNCTION_TABLE( void, R_LightEffectsWorldFunctionTableConstDirectional, ( const LightDesc_t* pLightDesc, const lightpos_t *light, const Vector& normal, Vector &dest, float flDirectionalConstant ), 256 )
|
|
{
|
|
enum
|
|
{
|
|
LightType1 = ( nArgument & 0xC0 ) >> 6,
|
|
LightType2 = ( nArgument & 0x30 ) >> 4,
|
|
LightType3 = ( nArgument & 0x0C ) >> 2,
|
|
LightType4 = ( nArgument & 0x03 )
|
|
};
|
|
|
|
// VPROF( "R_LightEffectsWorld" );
|
|
|
|
#ifdef NO_AMBIENT_CUBE
|
|
dest[0] = dest[1] = dest[2] = 0.0f;
|
|
#endif
|
|
|
|
// FIXME: lighting effects for normal and position are independent!
|
|
// FIXME: these can be pre-calculated per normal
|
|
if( (LightType_t)LightType1 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[0].falloff *
|
|
CWorldLightAngleWrapperConstDirectional<LightType1>::WorldLightAngle( &pLightDesc[0],
|
|
pLightDesc[0].m_Direction, normal, light[0].delta, flDirectionalConstant );
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[0].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType2 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[1].falloff *
|
|
CWorldLightAngleWrapperConstDirectional<LightType2>::WorldLightAngle( &pLightDesc[1],
|
|
pLightDesc[1].m_Direction, normal, light[1].delta, flDirectionalConstant );
|
|
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[1].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType3 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[2].falloff *
|
|
CWorldLightAngleWrapperConstDirectional<LightType3>::WorldLightAngle( &pLightDesc[2],
|
|
pLightDesc[2].m_Direction, normal, light[2].delta, flDirectionalConstant );
|
|
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[2].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
|
|
if( (LightType_t)LightType4 != MATERIAL_LIGHT_DISABLE )
|
|
{
|
|
float ratio = light[3].falloff *
|
|
CWorldLightAngleWrapperConstDirectional<LightType4>::WorldLightAngle( &pLightDesc[3],
|
|
pLightDesc[3].m_Direction, normal, light[3].delta, flDirectionalConstant );
|
|
|
|
if (ratio > 0)
|
|
{
|
|
const float* pColor = (float*)&pLightDesc[3].m_Color;
|
|
dest[0] += pColor[0] * ratio;
|
|
dest[1] += pColor[1] * ratio;
|
|
dest[2] += pColor[2] * ratio;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Get the function table index
|
|
//-----------------------------------------------------------------------------
|
|
static int s_pLightMask[ 5 ] =
|
|
{
|
|
0, // No lights
|
|
0xC0, // 1 light
|
|
0xF0, // 2 lights
|
|
0xFC, // 3 lights
|
|
0xFF, // 4 lights
|
|
};
|
|
|
|
inline int R_LightEffectsWorldIndex(const LightDesc_t* pLightDesc, int nNumLights)
|
|
{
|
|
if ( nNumLights > 4 )
|
|
{
|
|
nNumLights = 4;
|
|
}
|
|
|
|
int nIndex = ((pLightDesc[0].m_Type & 0x3) << 6) | ((pLightDesc[1].m_Type & 0x3) << 4) | ( (pLightDesc[2].m_Type & 0x3) << 2) | (pLightDesc[3].m_Type & 0x3);
|
|
nIndex &= s_pLightMask[ nNumLights ];
|
|
|
|
Assert( nIndex >= 0 && nIndex < R_LightEffectsWorldFunctionTable::count );
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
/*
|
|
light_direction (light_pos - vertex_pos)
|
|
*/
|
|
// TODO: move cone calcs to position
|
|
// TODO: cone clipping calc's wont work for boxlight since the player asks for a single point. Not sure what the volume is.
|
|
TEMPLATE_FUNCTION_TABLE( float, R_WorldLightDistanceFalloffFunctionTable, ( const LightDesc_t *wl, const Vector& delta ), 8)
|
|
{
|
|
Assert( nArgument != 0 );
|
|
|
|
float dist2 = DotProduct( delta, delta );
|
|
|
|
// Cull out light beyond this radius
|
|
if (wl->m_Range != 0.f)
|
|
{
|
|
if (dist2 > wl->m_Range * wl->m_Range)
|
|
return 0.0f;
|
|
}
|
|
|
|
// The general purpose equation:
|
|
float fTotal = FLT_EPSILON;
|
|
|
|
if( nArgument & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0 )
|
|
{
|
|
fTotal = wl->m_Attenuation0;
|
|
}
|
|
|
|
if( nArgument & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1 )
|
|
{
|
|
fTotal += wl->m_Attenuation1 * FastSqrt( dist2 );
|
|
}
|
|
|
|
if( nArgument & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2 )
|
|
{
|
|
fTotal += wl->m_Attenuation2 * dist2;
|
|
}
|
|
|
|
return 1.0f / fTotal;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Calculate the falloff from the world lights
|
|
//-----------------------------------------------------------------------------
|
|
float FASTCALL R_WorldLightDistanceFalloff( const LightDesc_t *wl, const Vector& delta )
|
|
{
|
|
// Ensure no invalid flags are set
|
|
Assert( ! ( wl->m_Flags & ~(LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2|LIGHTTYPE_OPTIMIZATIONFLAGS_DERIVED_VALUES_CALCED) ) );
|
|
|
|
// calculate falloff
|
|
int flags = wl->m_Flags & (LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2);
|
|
return R_WorldLightDistanceFalloffFunctionTable::functions[flags](wl, delta);
|
|
}
|
|
|
|
#if defined( _WIN32 ) && !defined( _X360 )
|
|
fltx4 FASTCALL R_WorldLightDistanceFalloff( const LightDesc_t *wl, const FourVectors &delta )
|
|
{
|
|
// !!speed!!: lights could store m_Attenuation2,m_Attenuation1, and m_Range^2 copies in replicated SSE format.
|
|
|
|
// Ensure no invalid flags are set
|
|
Assert( ! ( wl->m_Flags & ~(LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1|LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2|LIGHTTYPE_OPTIMIZATIONFLAGS_DERIVED_VALUES_CALCED) ) );
|
|
|
|
fltx4 dist2 = delta*delta;
|
|
|
|
fltx4 fTotal;
|
|
|
|
if( wl->m_Flags & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION0 )
|
|
{
|
|
fTotal = ReplicateX4(wl->m_Attenuation0);
|
|
}
|
|
else
|
|
fTotal= ReplicateX4(FLT_EPSILON); // !!speed!! replicate
|
|
|
|
if( wl->m_Flags & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION1 )
|
|
{
|
|
fTotal=AddSIMD(fTotal,MulSIMD(ReplicateX4(wl->m_Attenuation1),SqrtEstSIMD(dist2)));
|
|
}
|
|
|
|
if( wl->m_Flags & LIGHTTYPE_OPTIMIZATIONFLAGS_HAS_ATTENUATION2 )
|
|
{
|
|
fTotal=AddSIMD(fTotal,MulSIMD(ReplicateX4(wl->m_Attenuation2),dist2));
|
|
}
|
|
|
|
fTotal=ReciprocalEstSIMD(fTotal);
|
|
// Cull out light beyond this radius
|
|
// now, zero out elements for which dist2 was > range^2. !!speed!! lights should store dist^2 in sse format
|
|
if (wl->m_Range != 0.f)
|
|
{
|
|
fltx4 RangeSquared = ReplicateX4(wl->m_Range*wl->m_Range); // !!speed!!
|
|
fTotal=AndSIMD(fTotal,CmpLtSIMD(dist2,RangeSquared));
|
|
}
|
|
return fTotal;
|
|
}
|
|
#endif
|
|
|
|
|
|
int CStudioRender::R_LightGlintPosition( int index, const Vector& org, Vector& delta, Vector& intensity )
|
|
{
|
|
if (index >= m_pRC->m_NumLocalLights)
|
|
return false;
|
|
|
|
R_WorldLightDelta( &m_pRC->m_LocalLights[index], org, delta );
|
|
float falloff = R_WorldLightDistanceFalloff( &m_pRC->m_LocalLights[index], delta );
|
|
|
|
VectorMultiply( m_pRC->m_LocalLights[index].m_Color, falloff, intensity );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Setup up the function table
|
|
//-----------------------------------------------------------------------------
|
|
void CStudioRender::R_InitLightEffectsWorld3()
|
|
{
|
|
// set the function pointer
|
|
int index = R_LightEffectsWorldIndex( m_pRC->m_LocalLights, m_pRC->m_NumLocalLights );
|
|
R_LightEffectsWorld3 = R_LightEffectsWorldFunctionTable::functions[index];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Performs lighting functions common to the ComputeLighting and ComputeLightingConstantDirectional
|
|
// returns the index of the LightEffectsWorldFunction to use
|
|
//-----------------------------------------------------------------------------
|
|
static int ComputeLightingCommon( const Vector* pAmbient, int lightCount,
|
|
LightDesc_t* pLights, const Vector& pt, const Vector& normal, lightpos_t *pLightPos, Vector& lighting )
|
|
{
|
|
// Set up lightpos[i].dot, lightpos[i].falloff, and lightpos[i].delta for all lights
|
|
R_LightStrengthWorld( pt, lightCount, pLights, pLightPos );
|
|
|
|
// calculate ambient values from the ambient cube given a normal.
|
|
R_LightAmbient_3D( normal, pAmbient, lighting );
|
|
|
|
return R_LightEffectsWorldIndex( pLights, lightCount );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute the lighting at a point and normal
|
|
// Final Lighting is in linear space
|
|
//-----------------------------------------------------------------------------
|
|
void CStudioRenderContext::ComputeLighting( const Vector* pAmbient, int lightCount,
|
|
LightDesc_t* pLights, const Vector& pt, const Vector& normal, Vector& lighting )
|
|
{
|
|
if ( m_RC.m_Config.fullbright )
|
|
{
|
|
lighting.Init( 1.0f, 1.0f, 1.0f );
|
|
return;
|
|
}
|
|
|
|
if ( lightCount > ARRAYSIZE( m_pLightPos ) )
|
|
{
|
|
AssertMsg( 0, "Light count out of range in ComputeLighting\n" );
|
|
lightCount = ARRAYSIZE( m_pLightPos );
|
|
}
|
|
|
|
// Calculate color given lightpos_t lightpos, a normal, and the ambient
|
|
// color from the ambient cube calculated in ComputeLightingCommon
|
|
int index = ComputeLightingCommon( pAmbient, lightCount, pLights, pt, normal, m_pLightPos, lighting );
|
|
R_LightEffectsWorldFunctionTable::functions[index]( pLights, m_pLightPos, normal, lighting );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute the lighting at a point and normal
|
|
// Final Lighting is in linear space
|
|
// Uses flDirectionalAmount instead of directional components of lights
|
|
//-----------------------------------------------------------------------------
|
|
void CStudioRenderContext::ComputeLightingConstDirectional( const Vector* pAmbient, int lightCount,
|
|
LightDesc_t* pLights, const Vector& pt, const Vector& normal, Vector& lighting, float flDirectionalAmount )
|
|
{
|
|
if ( m_RC.m_Config.fullbright )
|
|
{
|
|
lighting.Init( 1.0f, 1.0f, 1.0f );
|
|
return;
|
|
}
|
|
|
|
if ( lightCount > ARRAYSIZE( m_pLightPos ) )
|
|
{
|
|
AssertMsg( 0, "Light count out of range in ComputeLighting\n" );
|
|
lightCount = ARRAYSIZE( m_pLightPos );
|
|
}
|
|
|
|
// Calculate color given lightpos_t lightpos, a normal, and the ambient
|
|
// color from the ambient cube calculated in ComputeLightingCommon
|
|
int index = ComputeLightingCommon( pAmbient, lightCount, pLights, pt, normal, m_pLightPos, lighting );
|
|
R_LightEffectsWorldFunctionTableConstDirectional::functions[index]( pLights, m_pLightPos, normal, lighting, flDirectionalAmount );
|
|
} |