Paranoia2/cl_dll/render/gl_dlight.cpp

779 lines
19 KiB
C++
Raw Normal View History

2020-08-31 18:50:41 +02:00
/*
gl_dlight.cpp - dynamic lighting
Copyright (C) 2014 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "hud.h"
#include <stringlib.h>
#include "cl_util.h"
#include "pm_defs.h"
#include "event_api.h"
#include "gl_local.h"
#include "gl_studio.h"
#include "gl_world.h"
#include "gl_grass.h"
/*
=============================================================================
PROJECTED LIGHTS
=============================================================================
*/
/*
===============
CL_ClearDlights
===============
*/
void CL_ClearDlights( void )
{
memset( tr.dlights, 0, sizeof( tr.dlights ));
}
/*
===============
CL_AllocDlight
===============
*/
CDynLight *CL_AllocDlight( int key )
{
CDynLight *dl;
// first look for an exact key match
if( key )
{
dl = tr.dlights;
for( int i = 0; i < MAX_DLIGHTS; i++, dl++ )
{
if( dl->key == key )
{
// reuse this light
return dl;
}
}
}
float time = GET_CLIENT_TIME();
// then look for anything else
dl = tr.dlights;
for( int i = 0; i < MAX_DLIGHTS; i++, dl++ )
{
if( dl->die < time && dl->key == 0 )
{
memset( dl, 0, sizeof( *dl ));
dl->key = key;
return dl;
}
}
dl = &tr.dlights[0];
memset( dl, 0, sizeof( *dl ));
dl->key = key;
return dl;
}
/*
===============
CL_DecayLights
===============
*/
void CL_DecayLights( void )
{
float time = GET_CLIENT_TIME();
CDynLight *pl = tr.dlights;
for( int i = 0; i < MAX_DLIGHTS; i++, pl++ )
{
if( !pl->radius ) continue;
pl->radius -= tr.frametime * pl->decay;
if( pl->radius < 0.0f ) pl->radius = 0.0f;
if( pl->Expired( ))
memset( pl, 0, sizeof( *pl ));
}
}
//=====================================
// HasDynamicLights
//
// Return count dynamic lights for current frame
//=====================================
int HasDynamicLights( void )
{
int numDlights = 0;
if( !worldmodel->lightdata || !CVAR_TO_BOOL( cv_dynamiclight ))
return numDlights;
for( int i = 0; i < MAX_DLIGHTS; i++ )
{
CDynLight *pl = &tr.dlights[i];
if( pl->Expired( )) continue;
numDlights++;
}
return numDlights;
}
//=====================================
// HasStaticLights
//
// Return count static lights for current frame
//=====================================
int HasStaticLights( void )
{
int i, numLights = 0;
mworldlight_t *wl;
for( i = 0, wl = world->worldlights; i < world->numworldlights; i++, wl++ )
{
if( wl->emittype == emit_ignored )
continue;
if( !CHECKVISBIT( RI->view.vislight, i ))
continue;
numLights++;
}
return numLights;
}
/*
=============================================================================
DYNAMIC LIGHTS
=============================================================================
*/
/*
==================
R_AnimateLight
==================
*/
void R_AnimateLight( void )
{
int i, k, flight, clight;
float l, lerpfrac, backlerp;
float scale = 1.0f;
lightstyle_t *ls;
scale = tr.diffuseFactor;
if( tr.realframecount != 1 && !CVAR_TO_BOOL( r_lightstyles ))
return;
// light animations
// 'm' is normal light, 'a' is no light, 'z' is double bright
for( i = 0; i < MAX_LIGHTSTYLES; i++ )
{
ls = GET_LIGHTSTYLE( i );
if( !worldmodel->lightdata )
{
tr.lightstyle[i] = 256.0f * scale;
continue;
}
flight = (int)Q_floor( ls->time * 10.0f );
clight = (int)Q_ceil( ls->time * 10.0f );
lerpfrac = ( ls->time * 10 ) - flight;
backlerp = 1.0f - lerpfrac;
if( !ls->length )
{
tr.lightstyle[i] = 256.0f * scale;
continue;
}
else if( ls->length == 1 )
{
float value = ls->map[0];
// turn off the baked sunlight
if( tr.sun_light_enabled && i == LS_SKY )
value = (float)('a' - 'a');
// single length style so don't bother interpolating
tr.lightstyle[i] = value * 22.0f * scale;
continue;
}
else if( !ls->interp || !CVAR_TO_BOOL( r_lightstyle_lerping ))
{
tr.lightstyle[i] = ls->map[flight%ls->length] * 22.0f * scale;
continue;
}
// interpolate animating light
// frame just gone
k = ls->map[flight % ls->length];
l = (float)( k * 22.0f ) * backlerp;
// upcoming frame
k = ls->map[clight % ls->length];
l += (float)( k * 22.0f ) * lerpfrac;
tr.lightstyle[i] = l * scale;
}
}
/*
=======================================================================
GATHER DYNAMIC LIGHTING
=======================================================================
*/
/*
=================
R_LightsForPoint
=================
*/
Vector R_LightsForPoint( const Vector &point, float radius )
{
Vector lightColor;
if( radius <= 0.0f )
radius = 1.0f;
lightColor = g_vecZero;
for( int lnum = 0; lnum < MAX_DLIGHTS; lnum++ )
{
CDynLight *dl = &tr.dlights[lnum];
float atten = 1.0f;
if( dl->type == LIGHT_DIRECTIONAL )
continue;
if( dl->die < GET_CLIENT_TIME() || !dl->radius )
continue;
Vector dir = (dl->origin - point);
float dist = dir.Length();
if( !dist || dist > ( dl->radius + radius ))
continue;
if( dl->frustum.CullSphere( point, radius ))
continue;
atten = 1.0 - saturate( pow( dist * ( 1.0f / dl->radius ), 2.2f ));
if( atten <= 0.0 ) continue; // fast reject
if( dl->type == LIGHT_SPOT )
{
Vector lightDir = dl->frustum.GetPlane( FRUSTUM_FAR )->normal.Normalize();
float fov_x, fov_y;
// BUGBUG: we use 5:4 aspect not an 4:3
if( dl->flags & DLF_ASPECT3X4 )
fov_y = dl->fov * (5.0f / 4.0f);
else if( dl->flags & DLF_ASPECT4X3 )
fov_y = dl->fov * (4.0f / 5.0f);
else fov_y = dl->fov;
fov_x = dl->fov;
// spot attenuation
float spotDot = DotProduct( dir.Normalize(), lightDir );
fov_x = DEG2RAD( fov_x * 0.25f );
fov_y = DEG2RAD( fov_y * 0.25f );
float spotCos = cos( fov_x + fov_y );
if( spotDot < spotCos ) continue;
}
lightColor += (dl->color * 0.5f * atten);
}
return lightColor;
}
/*
================
R_GetLightVectors
Get light vectors for entity
================
*/
void R_GetLightVectors( cl_entity_t *pEnt, Vector &origin, Vector &angles )
{
// fill default case
origin = pEnt->origin;
angles = pEnt->angles;
// try to grab position from attachment
if( pEnt->curstate.aiment > 0 && pEnt->curstate.movetype == MOVETYPE_FOLLOW )
{
cl_entity_t *pParent = GET_ENTITY( pEnt->curstate.aiment );
studiohdr_t *pStudioHeader = (studiohdr_t *)IEngineStudio.Mod_Extradata( pParent->model );
if( pParent && pParent->model && pStudioHeader != NULL )
{
// make sure what model really has attachements
if( pEnt->curstate.body > 0 && ( pStudioHeader && pStudioHeader->numattachments > 0 ))
{
int num = bound( 1, pEnt->curstate.body, MAXSTUDIOATTACHMENTS );
R_StudioAttachmentPosAng( pParent, num - 1, &origin, &angles );
angles[PITCH] = -angles[PITCH]; // stupid quake bug
}
else if( pParent->curstate.movetype == MOVETYPE_STEP )
{
origin = pParent->origin;
angles = pParent->angles;
// add the eye position for monster
if( pParent->curstate.eflags & EFLAG_SLERP )
origin += pStudioHeader->eyeposition;
}
else
{
origin = pParent->origin;
angles = pParent->angles;
}
}
}
// all other parent types will be attached on the server
}
/*
================
R_SetupLightTexture
Must be called after R_SetupLightParams
================
*/
void R_SetupLightTexture( CDynLight *pl, int texture )
{
ASSERT( pl != NULL );
pl->spotlightTexture = texture;
}
/*
================
R_SetupLightParams
================
*/
void R_SetupLightParams( CDynLight *pl, const Vector &origin, const Vector &angles, float radius, float fov, int type, int flags )
{
pl->type = bound( LIGHT_SPOT, type, LIGHT_DIRECTIONAL );
if( pl->type == LIGHT_OMNI )
{
for( int i = 0; i < MAX_SHADOWMAPS; i++ )
pl->shadowTexture[i] = tr.depthCubemap; // stub
if( !GL_Support( R_TEXTURECUBEMAP_EXT ))
flags |= DLF_NOSHADOWS;
}
else
{
for( int i = 0; i < MAX_SHADOWMAPS; i++ )
pl->shadowTexture[i] = tr.depthTexture; // stub
}
if( pl->origin != origin || pl->angles != angles || pl->fov != fov || pl->radius != radius || pl->flags != flags )
{
pl->origin = origin;
pl->angles = angles;
pl->radius = radius;
pl->flags = flags;
pl->update = true;
pl->fov = fov;
}
}
/*
================
R_SetupLightProjection
General setup light projections.
Calling only once per frame
================
*/
void R_SetupLightProjection( CDynLight *pl )
{
if( !pl->update )
{
if( pl->type != LIGHT_DIRECTIONAL )
{
if( !R_ScissorForFrustum( &pl->frustum, &pl->x, &pl->y, &pl->w, &pl->h ))
SetBits( pl->flags, DLF_CULLED );
else ClearBits( pl->flags, DLF_CULLED );
}
return;
}
if( pl->type == LIGHT_SPOT )
{
float fov_x, fov_y;
// BUGBUG: we use 5:4 aspect not an 4:3
if( pl->flags & DLF_ASPECT3X4 )
fov_y = pl->fov * (5.0f / 4.0f);
else if( pl->flags & DLF_ASPECT4X3 )
fov_y = pl->fov * (4.0f / 5.0f);
else fov_y = pl->fov;
// e.g. for fake cinema projectors
if( FBitSet( pl->flags, DLF_FLIPTEXTURE ))
fov_x = -pl->fov;
else fov_x = pl->fov;
pl->projectionMatrix.CreateProjection( fov_x, fov_y, Z_NEAR_LIGHT, pl->radius );
pl->modelviewMatrix.CreateModelview(); // init quake world orientation
pl->viewMatrix = matrix4x4( pl->origin, pl->angles );
// transform projector by position and angles
pl->modelviewMatrix.ConcatRotate( -pl->angles.z, 1, 0, 0 );
pl->modelviewMatrix.ConcatRotate( -pl->angles.x, 0, 1, 0 );
pl->modelviewMatrix.ConcatRotate( -pl->angles.y, 0, 0, 1 );
pl->modelviewMatrix.ConcatTranslate( -pl->origin.x, -pl->origin.y, -pl->origin.z );
pl->frustum.InitProjection( pl->viewMatrix, Z_NEAR_LIGHT, pl->radius, pl->fov, fov_y );
pl->frustum.ComputeFrustumBounds( pl->absmin, pl->absmax );
pl->frustum.DisablePlane( FRUSTUM_FAR ); // only use plane.normal
}
else if( pl->type == LIGHT_OMNI )
{
pl->modelviewMatrix.CreateModelview();
pl->viewMatrix = matrix4x4( pl->origin, g_vecZero );
pl->projectionMatrix.CreateProjection( 90.0f, 90.0f, Z_NEAR_LIGHT, pl->radius );
// transform omnilight by position
pl->modelviewMatrix.ConcatTranslate( -pl->origin.x, -pl->origin.y, -pl->origin.z );
pl->frustum.InitBoxFrustum( pl->origin, pl->radius );
pl->frustum.ComputeFrustumBounds( pl->absmin, pl->absmax );
}
else if( pl->type == LIGHT_DIRECTIONAL )
{
Vector skyDir, angles, up;
skyDir = tr.sky_normal.Normalize();
VectorAngles2( skyDir, angles );
AngleVectors( angles, NULL, NULL, up );
pl->viewMatrix.LookAt( tr.cached_vieworigin, skyDir, up );
pl->modelviewMatrix = pl->viewMatrix;
ClearBounds( pl->absmin, pl->absmax );
}
else
{
HOST_ERROR( "R_SetupLightProjection: unknown light type %i\n", pl->type );
}
if( pl->type != LIGHT_DIRECTIONAL )
{
matrix4x4 projectionView, s1;
projectionView = pl->projectionMatrix.Concat( pl->modelviewMatrix );
pl->lightviewProjMatrix = projectionView;
s1.CreateTranslate( 0.5f, 0.5f, 0.5f );
s1.ConcatScale( 0.5f, 0.5f, 0.5f );
pl->textureMatrix[0] = projectionView;
pl->shadowMatrix[0] = s1.Concat( projectionView );
if( !R_ScissorForFrustum( &pl->frustum, &pl->x, &pl->y, &pl->w, &pl->h ))
SetBits( pl->flags, DLF_CULLED );
else ClearBits( pl->flags, DLF_CULLED );
}
pl->update = false;
}
/*
================
R_SetupDynamicLights
================
*/
void R_SetupDynamicLights( void )
{
CDynLight *pl;
dlight_t *dl;
for( int lnum = 0; lnum < MAX_ENGINE_DLIGHTS; lnum++ )
{
dl = GET_DYNAMIC_LIGHT( lnum );
pl = &tr.dlights[MAX_ENGINE_DLIGHTS+lnum];
// NOTE: here we copies dlight settings 'as-is'
// without reallocating by key because key may
// be set indirectly without call CL_AllocDlight
if( dl->die < GET_CLIENT_TIME() || !dl->radius )
{
// light is expired. Clear it
memset( pl, 0, sizeof( *pl ));
continue;
}
pl->key = dl->key;
pl->die = dl->die + tr.frametime;
pl->decay = dl->decay;
pl->color.x = dl->color.r * (1.0 / 255.0f);
pl->color.y = dl->color.g * (1.0 / 255.0f);
pl->color.z = dl->color.b * (1.0 / 255.0f);
pl->origin = dl->origin;
pl->radius = dl->radius;
pl->type = LIGHT_OMNI;
pl->update = true;
R_SetupLightProjection( pl );
}
pl = tr.dlights;
for( int i = 0; i < MAX_DLIGHTS; i++, pl++ )
{
if( pl->Expired( )) continue;
R_SetupLightProjection( pl );
}
}
/*
=======================================================================
WORLDLIGHTS PROCESSING
=======================================================================
*/
static vec_t LightDistanceFalloff( const mworldlight_t *wl, const Vector &direction )
{
Vector delta = direction;
float dist = VectorNormalize( delta );
float dot = 1.0f; // assume dot is 1.0f
dist = Q_max( dist, 1.0 );
switch( wl->emittype )
{
case emit_surface:
return dot / (dist * dist);
case emit_skylight:
return dot;
break;
case emit_spotlight: // directional & positional
case emit_point:
// cull out stuff that's too far
if( dist > wl->radius )
return 0.0f;
return dot / (dist * dist);
break;
}
return 1.0f;
}
//-----------------------------------------------------------------------------
// This method returns the effective intensity of a light as seen from
// a particular point. PVS is used to speed up the task.
//-----------------------------------------------------------------------------
static float LightIntensityAtPoint( mworldlight_t *wl, const Vector &mid, bool skipZ )
{
lightzbuffer_t *pZBuf = world->shadowzbuffers;
Vector direction;
// special case lights
if( wl->emittype == emit_skylight )
{
// check to see if you can hit the sky texture
Vector end = mid + wl->normal * -BOGUS_RANGE; // max_range * sqrt(3)
msurface_t *surf = gEngfuncs.pEventAPI->EV_TraceSurface( 0, (float *)&mid, (float *)end );
// here, we didn't hit the sky, so we must be in shadow
if( !surf || !FBitSet( surf->flags, SURF_DRAWSKY ))
return 0.0f;
return 1.0f;
}
// all other lights
// check distance
direction = wl->origin - mid;
float ratio = LightDistanceFalloff( wl, direction );
// Early out for really low-intensity lights
// That way we don't need to ray-cast or normalize
float intensity = VectorMax( wl->intensity );
if( intensity * ratio < 4e-3 )
return 0.0f;
if( skipZ ) return ratio;
float dist = VectorNormalize( direction );
float flTraceDistance = dist;
// check if we are so close to the light that we shouldn't use our coarse z buf
if( dist < 8 * SHADOW_ZBUF_RES )
pZBuf = NULL;
LightShadowZBufferSample_t *pSample = NULL;
Vector epnt = mid;
if( pZBuf )
{
pSample = &( pZBuf->GetSample( direction ));
if(( pSample->m_flHitDistance < pSample->m_flTraceDistance ) || ( pSample->m_flTraceDistance >= dist ))
{
// hit!
if( dist > pSample->m_flHitDistance + 8 ) // shadow hit
return 0;
return ratio;
}
// cache miss
flTraceDistance = Q_max( 100.0f, 2.0f * dist ); // trace a little further for better caching
epnt += direction * ( dist - flTraceDistance );
}
pmtrace_t pm;
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
gEngfuncs.pEventAPI->EV_PlayerTrace( wl->origin, epnt, PM_WORLD_ONLY, -1, &pm );
// pm.fraction = 1.0f - pm.fraction;
float flHitDistance = ( pm.startsolid ) ? FLT_EPSILON : ( pm.fraction ) * flTraceDistance;
if( pSample )
{
pSample->m_flTraceDistance = flTraceDistance;
pSample->m_flHitDistance = ( pm.fraction >= 1.0 ) ? 1.0e23 : flHitDistance;
}
if( dist > flHitDistance + 8 )
return 0.0f;
return ratio;
}
static float LightIntensityInBox( mworldlight_t *wl, const Vector &mid, const Vector &mins, const Vector &maxs, bool skipZ )
{
float sphereRadius;
float angle, sinAngle;
float dist, distSqr;
// Choose the point closest on the box to the light to get max intensity
// within the box....
switch( wl->emittype )
{
case emit_spotlight: // directional & positional
sphereRadius = (maxs - mid).Length();
// first do a sphere/sphere check
dist = (wl->origin - mid).Length();
if( dist > (sphereRadius + wl->radius ))
return 0;
// PERFORMANCE: precalc this and store in the light?
angle = acos( wl->stopdot2 );
sinAngle = sin( angle );
if( !IsSphereIntersectingCone( mid, sphereRadius, wl->origin, wl->normal, sinAngle, wl->stopdot2 ))
return 0;
// NOTE: fall through to radius check in point case
case emit_point:
distSqr = CalcSqrDistanceToAABB( mins, maxs, wl->origin );
if( distSqr > wl->radius * wl->radius )
return 0;
break;
case emit_surface: // directional & positional, fixed cone size
sphereRadius = (maxs - mid).Length();
// first do a sphere/sphere check
dist = (wl->origin - mid).Length();
if( dist > ( sphereRadius + wl->radius ))
return 0;
// PERFORMANCE: precalc this and store in the light?
if( !IsSphereIntersectingCone( mid, sphereRadius, wl->origin, wl->normal, 1.0f, 0.0f ))
return 0;
break;
}
return LightIntensityAtPoint( wl, mid, skipZ );
}
/*
=================
R_FindWorldLights
search for lights that potentially can lit bbox
=================
*/
void R_FindWorldLights( const Vector &origin, const Vector &mins, const Vector &maxs, byte lights[MAXDYNLIGHTS], bool skipZ )
{
mworldlight_t *wl = world->worldlights;
Vector absmin = origin + mins;
Vector absmax = origin + maxs;
vec2_t indexes[32];
int count = 0;
for( int i = 0; i < world->numworldlights; i++, wl++ )
{
if( !Mod_BoxVisible( absmin, absmax, wl->pvs ))
continue;
float ratio = LightIntensityInBox( wl, origin, mins, maxs, skipZ );
// no light contribution?
if( ratio <= 0.0f ) continue;
Vector add = wl->intensity * ratio;
float illum = VectorMax( add );
//Msg( "#%i, type %d, illum %.5f, intensity %g %g %g\n", i, wl->emittype, illum, wl->intensity[0], wl->intensity[1], wl->intensity[2] );
if( illum <= 4e-3 )
continue;
if( count >= ARRAYSIZE( indexes ) / 2 )
break;
indexes[count][0] = i;
indexes[count][1] = illum;
count++;
}
memset( lights, 255, sizeof( byte ) * MAXDYNLIGHTS );
get_next_light:
float maxIllum = 0.0;
int ignored = -1;
int light = 255;
for( i = 0; i < count; i++ )
{
if( indexes[i][0] == -1.0f )
continue;
// skylight has a maximum priority
if( indexes[i][1] > maxIllum )
{
maxIllum = indexes[i][1];
light = indexes[i][0];
ignored = i;
}
}
if( ignored == -1 )
return;
for( i = 0; i < (int)cv_deferred_maxlights->value && lights[i] != 255; i++ );
if( i < (int)cv_deferred_maxlights->value )
lights[i] = light; // nearest light for surf
indexes[ignored][0] = -1; // this light is handled
// if( count > (int)cv_deferred_maxlights->value && i == (int)cv_deferred_maxlights->value )
// Msg( "skipped light %i intensity %g, type %d\n", light, maxIllum, world->worldlights[light].emittype );
goto get_next_light;
}