r_shadow.h File Reference

#include "qtypes.h"
#include "taskqueue.h"
#include "matrixlib.h"

Include dependency graph for r_shadow.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	r_shadow_bouncegrid_photon_path_t
struct	r_shadow_bouncegrid_photon_t
struct	r_shadow_bouncegrid_settings_t
struct	r_shadow_bouncegrid_state_t

Macros
#define	LP_DYNLIGHT   4
#define	LP_LIGHTMAP   1
#define	LP_RTWORLD   2
#define	PHOTON_MAX_PATHS   11
#define	R_SHADOW_SHADOWMAP_NUMCUBEMAPS   8

Functions
void	R_CompleteLightPoint (float *ambient, float *diffuse, float *lightdir, const vec3_t p, const int flags, float lightmapintensity, float ambientintensity)
void	R_RTLight_Compile (struct rtlight_s *rtlight)
void	R_RTLight_Uncompile (struct rtlight_s *rtlight)
void	R_RTLight_Update (struct rtlight_s *rtlight, int isstatic, matrix4x4_t *matrix, vec3_t color, int style, const char *cubemapname, int shadow, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)
int	R_Shadow_CalcSphereSideMask (const vec3_t p1, float radius, float bias)
int	R_Shadow_CalcTriangleSideMask (const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
int	R_Shadow_ChooseSidesFromBox (int firsttriangle, int numtris, const float *invertex3f, const int *elements, const matrix4x4_t *worldtolight, const vec3_t projectorigin, const vec3_t projectdirection, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs, int *totals)
void	R_Shadow_ClearShadowMapTexture (void)
void	R_Shadow_ClearStencil (void)
void	R_Shadow_DrawCoronas (void)
void	R_Shadow_DrawLights (void)
void	R_Shadow_DrawPrepass (void)
void	R_Shadow_DrawShadowMaps (void)
void	R_Shadow_Init (void)
void	R_Shadow_PrepareLights (void)
void	R_Shadow_PrepareModelShadows (void)
void	R_Shadow_PrepareShadowMark (int numtris)
void	R_Shadow_PrepareShadowSides (int numtris)
void	R_Shadow_RenderLighting (int texturenumsurfaces, const struct msurface_s **texturesurfacelist)
void	R_Shadow_RenderMode_ActiveLight (const struct rtlight_s *rtlight)
void	R_Shadow_RenderMode_Begin (void)
void	R_Shadow_RenderMode_DrawDeferredLight (qbool shadowmapping)
void	R_Shadow_RenderMode_End (void)
void	R_Shadow_RenderMode_Lighting (qbool transparent, qbool shadowmapping, qbool noselfshadowpass)
void	R_Shadow_RenderMode_Reset (void)
void	R_Shadow_RenderMode_VisibleLighting (qbool transparent)
qbool	R_Shadow_ScissorForBBox (const float *mins, const float *maxs)
void	R_Shadow_SetupEntityLight (const struct entity_render_s *ent)
void	R_Shadow_ShadowMapFromList (int numverts, int numtris, const float *vertex3f, const int *elements, int numsidetris, const int *sidetotals, const unsigned char *sides, const int *sidetris)
qbool	R_Shadow_ShadowMappingEnabled (void)
void	R_Shadow_UpdateWorldLightSelection (void)

Variables
matrix4x4_t	matrix_attenuationxyz
matrix4x4_t	matrix_attenuationz
int	maxshadowmark
int	maxshadowsides
int	numshadowmark
int	numshadowsides
r_shadow_bouncegrid_state_t	r_shadow_bouncegrid_state
struct cvar_s	r_shadow_bumpscale_basetexture
struct cvar_s	r_shadow_bumpscale_bumpmap
struct rtlight_s *	r_shadow_compilingrtlight
struct cvar_s	r_shadow_debuglight
struct cvar_s	r_shadow_frontsidecasting
struct cvar_s	r_shadow_gloss
struct cvar_s	r_shadow_gloss2exponent
struct cvar_s	r_shadow_gloss2intensity
struct cvar_s	r_shadow_glossexact
struct cvar_s	r_shadow_glossexponent
struct cvar_s	r_shadow_glossintensity
struct cvar_s	r_shadow_lightattenuationpower
struct cvar_s	r_shadow_lightattenuationscale
struct cvar_s	r_shadow_lightintensityscale
struct cvar_s	r_shadow_lightradiusscale
struct cvar_s	r_shadow_projectdistance
struct cvar_s	r_shadow_realtime_dlight
struct cvar_s	r_shadow_realtime_dlight_portalculling
struct cvar_s	r_shadow_realtime_dlight_shadows
struct cvar_s	r_shadow_realtime_dlight_svbspculling
struct cvar_s	r_shadow_realtime_world
struct cvar_s	r_shadow_realtime_world_compile
struct cvar_s	r_shadow_realtime_world_compileportalculling
struct cvar_s	r_shadow_realtime_world_compileshadow
struct cvar_s	r_shadow_realtime_world_compilesvbsp
struct cvar_s	r_shadow_realtime_world_lightmaps
struct cvar_s	r_shadow_realtime_world_shadows
struct cvar_s	r_shadow_scissor
int *	shadowmark
int	shadowmarkcount
int *	shadowmarklist
unsigned char *	shadowsides
int *	shadowsideslist

Macro Definition Documentation

LP_DYNLIGHT

#define LP_DYNLIGHT   4

Definition at line 194 of file r_shadow.h.

Referenced by CL_UpdateEntityShading_Entity(), R_CompleteLightPoint(), R_DrawParticle_TransparentCallback(), and R_HDR_UpdateIrisAdaptation().

LP_LIGHTMAP

#define LP_LIGHTMAP   1

Definition at line 192 of file r_shadow.h.

Referenced by CL_UpdateEntityShading_Entity(), R_CompleteLightPoint(), R_DrawParticle_TransparentCallback(), R_HDR_UpdateIrisAdaptation(), and VM_CL_getlight().

LP_RTWORLD

#define LP_RTWORLD   2

Definition at line 193 of file r_shadow.h.

Referenced by CL_UpdateEntityShading_Entity(), R_CompleteLightPoint(), R_DrawParticle_TransparentCallback(), and R_HDR_UpdateIrisAdaptation().

PHOTON_MAX_PATHS

#define PHOTON_MAX_PATHS   11

Definition at line 68 of file r_shadow.h.

Referenced by R_Shadow_BounceGrid_TracePhotons_Shot().

R_SHADOW_SHADOWMAP_NUMCUBEMAPS

#define R_SHADOW_SHADOWMAP_NUMCUBEMAPS   8

Definition at line 12 of file r_shadow.h.

Function Documentation

R_CompleteLightPoint()

void R_CompleteLightPoint	(	float *	ambient,
		float *	diffuse,
		float *	lightdir,
		const vec3_t	p,
		const int	flags,
		float	lightmapintensity,
		float	ambientintensity )

Definition at line 6014 of file r_shadow.c.

{
    int i, numlights, flag, q;
    rtlight_t *light;
    dlight_t *dlight;
    float relativepoint[3];
    float color[3];
    float dist;
    float dist2;
    float intensity;
    float sa[3], sx[3], sy[3], sz[3], sd[3];
    float lightradius2;
 
    // use first order spherical harmonics to combine directional lights
    for (q = 0; q < 3; q++)
        sa[q] = sx[q] = sy[q] = sz[q] = sd[q] = 0;
 
    if (flags & LP_LIGHTMAP)
    {
        if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
        {
            float tempambient[3];
            for (q = 0; q < 3; q++)
                tempambient[q] = color[q] = relativepoint[q] = 0;
            r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
            // calculate a weighted average light direction as well
            intensity = VectorLength(color);
            for (q = 0; q < 3; q++)
            {
                sa[q] += (0.5f * color[q] + tempambient[q]) * lightmapintensity;
                sx[q] += (relativepoint[0] * color[q]) * lightmapintensity;
                sy[q] += (relativepoint[1] * color[q]) * lightmapintensity;
                sz[q] += (relativepoint[2] * color[q]) * lightmapintensity;
                sd[q] += (intensity * relativepoint[q]) * lightmapintensity;
            }
        }
        else
        {
            // unlit map - fullbright but scaled by lightmapintensity
            for (q = 0; q < 3; q++)
                sa[q] += lightmapintensity;
        }
    }
 
    if (flags & LP_RTWORLD)
    {
        flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
        numlights = (int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
        for (i = 0; i < numlights; i++)
        {
            dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
            if (!dlight)
                continue;
            light = &dlight->rtlight;
            if (!(light->flags & flag))
                continue;
            // sample
            lightradius2 = light->radius * light->radius;
            VectorSubtract(light->shadoworigin, p, relativepoint);
            dist2 = VectorLength2(relativepoint);
            if (dist2 >= lightradius2)
                continue;
            dist = sqrt(dist2) / light->radius;
            intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
            if (intensity <= 0.0f)
                continue;
            if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
                continue;
            for (q = 0; q < 3; q++)
                color[q] = light->currentcolor[q] * intensity;
            intensity = VectorLength(color);
            VectorNormalize(relativepoint);
            for (q = 0; q < 3; q++)
            {
                sa[q] += 0.5f * color[q];
                sx[q] += relativepoint[0] * color[q];
                sy[q] += relativepoint[1] * color[q];
                sz[q] += relativepoint[2] * color[q];
                sd[q] += intensity * relativepoint[q];
            }
        }
        // FIXME: sample bouncegrid too!
    }
 
    if (flags & LP_DYNLIGHT)
    {
        // sample dlights
        for (i = 0;i < r_refdef.scene.numlights;i++)
        {
            light = r_refdef.scene.lights[i];
            // sample
            lightradius2 = light->radius * light->radius;
            VectorSubtract(light->shadoworigin, p, relativepoint);
            dist2 = VectorLength2(relativepoint);
            if (dist2 >= lightradius2)
                continue;
            dist = sqrt(dist2) / light->radius;
            intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
            if (intensity <= 0.0f)
                continue;
            if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
                continue;
            for (q = 0; q < 3; q++)
                color[q] = light->currentcolor[q] * intensity;
            intensity = VectorLength(color);
            VectorNormalize(relativepoint);
            for (q = 0; q < 3; q++)
            {
                sa[q] += 0.5f * color[q];
                sx[q] += relativepoint[0] * color[q];
                sy[q] += relativepoint[1] * color[q];
                sz[q] += relativepoint[2] * color[q];
                sd[q] += intensity * relativepoint[q];
            }
        }
    }
 
    // calculate the weighted-average light direction (bentnormal)
    for (q = 0; q < 3; q++)
        lightdir[q] = sd[q];
    VectorNormalize(lightdir);
    for (q = 0; q < 3; q++)
    {
        // extract the diffuse color along the chosen direction and scale it
        diffuse[q] = (lightdir[0] * sx[q] + lightdir[1] * sy[q] + lightdir[2] * sz[q]);
        // subtract some of diffuse from ambient
        ambient[q] = sa[q] + -0.333f * diffuse[q] + ambientintensity;
    }
}

References model_t::brush, CL_TraceLine(), collision_extendmovelength, color, rtlight_t::currentcolor, flags, rtlight_t::flags, trace_t::fraction, i, int(), intensity, LIGHTFLAG_NORMALMODE, LIGHTFLAG_REALTIMEMODE, model_brush_t::LightPoint, r_refdef_scene_t::lights, model_t::lit, LP_DYNLIGHT, LP_LIGHTMAP, LP_RTWORLD, MATERIALFLAGMASK_TRANSLUCENT, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), min, MOVE_NOMONSTERS, NULL, r_refdef_scene_t::numlights, r_refdef, r_shadow_lightattenuationdividebias, r_shadow_lightattenuationlinearscale, r_shadow_lightintensityscale, r_shadow_worldlightsarray, rtlight_t::radius, dlight_t::rtlight, r_refdef_scene_t::rtworld, r_refdef_t::scene, rtlight_t::shadow, rtlight_t::shadoworigin, sqrt(), SUPERCONTENTS_SOLID, cvar_t::value, VectorLength, VectorLength2, VectorNormalize, VectorSubtract, and r_refdef_scene_t::worldmodel.

Referenced by CL_UpdateEntityShading_Entity(), R_DrawParticle_TransparentCallback(), R_HDR_UpdateIrisAdaptation(), and VM_CL_getlight().

R_RTLight_Compile()

void R_RTLight_Compile

(

struct rtlight_s *

rtlight

)

R_RTLight_Uncompile()

void R_RTLight_Uncompile

(

struct rtlight_s *

rtlight

)

R_RTLight_Update()

void R_RTLight_Update	(	struct rtlight_s *	rtlight,
		int	isstatic,
		matrix4x4_t *	matrix,
		vec3_t	color,
		int	style,
		const char *	cubemapname,
		int	shadow,
		vec_t	corona,
		vec_t	coronasizescale,
		vec_t	ambientscale,
		vec_t	diffusescale,
		vec_t	specularscale,
		int	flags )

R_Shadow_CalcSphereSideMask()

int R_Shadow_CalcSphereSideMask	(	const vec3_t	p1,
		float	radius,
		float	bias )

Definition at line 966 of file r_shadow.c.

{
    // p is in the cubemap's local coordinate system
    // bias = border/(size - border)
    float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
    float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
    float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
    int mask = 0x3F;
    if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
    if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
    if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
    if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
    if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
    if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
    return mask;
}

References fabs(), and mask.

R_Shadow_CalcTriangleSideMask()

int R_Shadow_CalcTriangleSideMask	(	const vec3_t	p1,
		const vec3_t	p2,
		const vec3_t	p3,
		float	bias )

Definition at line 863 of file r_shadow.c.

{
    // p1, p2, p3 are in the cubemap's local coordinate system
    // bias = border/(size - border)
    int mask = 0x3F;
 
    float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
          dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
          dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
    if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
        mask &= (3<<4)
            | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
            | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
            | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
        mask &= (3<<4)
            | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
            | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))            
            | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
 
    dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
    dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
    dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
    if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
        mask &= (3<<0)
            | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
            | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))            
            | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
        mask &= (3<<0)
            | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
            | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
            | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
 
    dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
    dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
    dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
    if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
        mask &= (3<<2)
            | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
            | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
            | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
        mask &= (3<<2)
            | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
            | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
            | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
 
    return mask;
}

References fabs(), and mask.

Referenced by R_Shadow_ChooseSidesFromBox().

R_Shadow_ChooseSidesFromBox()

int R_Shadow_ChooseSidesFromBox	(	int	firsttriangle,
		int	numtris,
		const float *	invertex3f,
		const int *	elements,
		const matrix4x4_t *	worldtolight,
		const vec3_t	projectorigin,
		const vec3_t	projectdirection,
		const vec3_t	lightmins,
		const vec3_t	lightmaxs,
		const vec3_t	surfacemins,
		const vec3_t	surfacemaxs,
		int *	totals )

Definition at line 1058 of file r_shadow.c.

{
    int t, tend;
    const int *e;
    const float *v[3];
    float normal[3];
    vec3_t p[3];
    float bias;
    int mask, surfacemask = 0;
    if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
        return 0;
    bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
    tend = firsttriangle + numtris;
    if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
    {
        // surface box entirely inside light box, no box cull
        if (projectdirection)
        {
            for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
            {
                v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
                TriangleNormal(v[0], v[1], v[2], normal);
                if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
                {
                    Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
                    mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
                    surfacemask |= mask;
                    if(totals)
                    {
                        totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
                        shadowsides[numshadowsides] = mask;
                        shadowsideslist[numshadowsides++] = t;
                    }
                }
            }
        }
        else
        {
            for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
            {
                v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
                if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
                {
                    Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
                    mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
                    surfacemask |= mask;
                    if(totals)
                    {
                        totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
                        shadowsides[numshadowsides] = mask;
                        shadowsideslist[numshadowsides++] = t;
                    }
                }
            }
        }
    }
    else
    {
        // surface box not entirely inside light box, cull each triangle
        if (projectdirection)
        {
            for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
            {
                v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
                TriangleNormal(v[0], v[1], v[2], normal);
                if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
                 && TriangleBBoxOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
                {
                    Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
                    mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
                    surfacemask |= mask;
                    if(totals)
                    {
                        totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
                        shadowsides[numshadowsides] = mask;
                        shadowsideslist[numshadowsides++] = t;
                    }
                }
            }
        }
        else
        {
            for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
            {
                v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
                if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
                 && TriangleBBoxOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
                {
                    Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
                    mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
                    surfacemask |= mask;
                    if(totals)
                    {
                        totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
                        shadowsides[numshadowsides] = mask;
                        shadowsideslist[numshadowsides++] = t;
                    }
                }
            }
        }
    }
    return surfacemask;
}

References BoxesOverlap, BoxInsideBox, DotProduct, float, cvar_t::integer, mask, Matrix4x4_Transform(), normal, numshadowsides, PointInfrontOfTriangle, R_Shadow_CalcTriangleSideMask(), r_shadow_frontsidecasting, r_shadow_shadowmapborder, r_shadow_shadowmapmaxsize, shadowsides, shadowsideslist, TriangleBBoxOverlapsBox, TriangleNormal, and v.

Referenced by R_Mod_CompileShadowMap().

R_Shadow_ClearShadowMapTexture()

void R_Shadow_ClearShadowMapTexture

(

void

)

Definition at line 1480 of file r_shadow.c.

{
    r_viewport_t viewport;
    float clearcolor[4];
 
    // if they don't exist, create our textures now
    if (!r_shadow_shadowmap2ddepthtexture)
        R_Shadow_MakeShadowMap(r_shadow_shadowmaptexturesize);
    if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
        R_Shadow_MakeVSDCT();
 
    // we're setting up to render shadowmaps, so change rendermode
    r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
 
    R_Mesh_ResetTextureState();
    R_Shadow_RenderMode_Reset();
    if (r_shadow_shadowmap2ddepthbuffer)
        R_Mesh_SetRenderTargets(r_shadow_fbo2d);
    else
        R_Mesh_SetRenderTargets(r_shadow_fbo2d);
    R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL, false); // FIXME test if we have a skeletal model?
    GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
    GL_DepthMask(true);
    GL_DepthTest(true);
 
    // we have to set a viewport to clear anything in some renderpaths (D3D)
    R_Viewport_InitOrtho(&viewport, &identitymatrix, 0, 0, r_shadow_shadowmaptexturesize, r_shadow_shadowmaptexturesize, 0, 0, 1.0, 1.0, 0.001f, 1.0f, NULL);
    R_SetViewport(&viewport);
    GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
    if (r_shadow_shadowmap2ddepthbuffer)
        GL_ColorMask(1, 1, 1, 1);
    else
        GL_ColorMask(0, 0, 0, 0);
    switch (vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        GL_CullFace(r_refdef.view.cullface_back);
        break;
    }
    Vector4Set(clearcolor, 1, 1, 1, 1);
    if (r_shadow_shadowmap2ddepthbuffer)
        GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
    else
        GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
}

References r_refdef_view_t::cullface_back, GL_Clear(), GL_COLOR_BUFFER_BIT, GL_ColorMask(), GL_CullFace(), GL_DEPTH_BUFFER_BIT, GL_DepthMask(), GL_DepthTest(), GL_PolygonOffset(), GL_Scissor(), r_viewport_t::height, identitymatrix, NULL, R_Mesh_ResetTextureState(), R_Mesh_SetRenderTargets(), r_refdef, R_SetupShader_DepthOrShadow(), R_SetViewport(), r_shadow_fbo2d, R_Shadow_MakeShadowMap(), R_Shadow_MakeVSDCT(), r_shadow_rendermode, R_Shadow_RenderMode_Reset(), R_SHADOW_RENDERMODE_SHADOWMAP2D, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, r_shadow_shadowmapping_polygonfactor, r_shadow_shadowmapping_polygonoffset, r_shadow_shadowmaptexturesize, r_shadow_shadowmapvsdct, r_shadow_shadowmapvsdcttexture, R_Viewport_InitOrtho(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, cvar_t::value, Vector4Set, vid, r_refdef_t::view, r_viewport_t::width, r_viewport_t::x, and r_viewport_t::y.

Referenced by R_Shadow_DrawShadowMaps().

R_Shadow_ClearStencil()

void R_Shadow_ClearStencil

(

void

)

Definition at line 1430 of file r_shadow.c.

{
    GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 0);
    r_refdef.stats[r_stat_lights_clears]++;
}

References GL_Clear(), GL_STENCIL_BUFFER_BIT, NULL, r_refdef, r_stat_lights_clears, and r_refdef_t::stats.

R_Shadow_DrawCoronas()

void R_Shadow_DrawCoronas

(

void

)

Definition at line 4528 of file r_shadow.c.

{
    int i, flag;
    qbool usequery = false;
    size_t lightindex;
    dlight_t *light;
    rtlight_t *rtlight;
    size_t range;
    if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
        return;
    if (r_fb.water.renderingscene)
        return;
    flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
    R_EntityMatrix(&identitymatrix);
 
    range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
 
    // check occlusion of coronas, using occlusion queries or raytraces
    r_numqueries = 0;
    switch (vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        // buffer binding target GL_QUERY_BUFFER: Core since version 4.4
        usequery = r_coronas_occlusionquery.integer && vid.support.glversion >= 44;
#ifndef USE_GLES2
        if (usequery)
        {
            GL_ColorMask(0,0,0,0);
            if (r_maxqueries < ((unsigned int)range + r_refdef.scene.numlights) * 2)
            if (r_maxqueries < MAX_OCCLUSION_QUERIES)
            {
                i = r_maxqueries;
                r_maxqueries = ((unsigned int)range + r_refdef.scene.numlights) * 4;
                r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
                CHECKGLERROR
                qglGenQueries(r_maxqueries - i, r_queries + i);
                CHECKGLERROR
            }
            RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
            GL_BlendFunc(GL_ONE, GL_ZERO);
            GL_CullFace(GL_NONE);
            GL_DepthMask(false);
            GL_DepthRange(0, 1);
            GL_PolygonOffset(0, 0);
            GL_DepthTest(true);
            R_Mesh_ResetTextureState();
            R_SetupShader_Generic_NoTexture(false, false);
        }
#endif
        break;
    }
    for (lightindex = 0;lightindex < range;lightindex++)
    {
        light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
        if (!light)
            continue;
        rtlight = &light->rtlight;
        rtlight->corona_visibility = 0;
        rtlight->corona_queryindex_visiblepixels = 0;
        rtlight->corona_queryindex_allpixels = 0;
        if (!(rtlight->flags & flag))
            continue;
        if (rtlight->corona <= 0)
            continue;
        if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
            continue;
        R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
    }
    for (i = 0;i < r_refdef.scene.numlights;i++)
    {
        rtlight = r_refdef.scene.lights[i];
        rtlight->corona_visibility = 0;
        rtlight->corona_queryindex_visiblepixels = 0;
        rtlight->corona_queryindex_allpixels = 0;
        if (!(rtlight->flags & flag))
            continue;
        if (rtlight->corona <= 0)
            continue;
        R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
    }
    if (usequery)
        GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
 
    // now draw the coronas using the query data for intensity info
    for (lightindex = 0;lightindex < range;lightindex++)
    {
        light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
        if (!light)
            continue;
        rtlight = &light->rtlight;
        if (rtlight->corona_visibility <= 0)
            continue;
        R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
    }
    for (i = 0;i < r_refdef.scene.numlights;i++)
    {
        rtlight = r_refdef.scene.lights[i];
        if (rtlight->corona_visibility <= 0)
            continue;
        R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
    }
}

References CHECKGLERROR, r_refdef_view_t::colormask, rtlight_t::corona, rtlight_t::corona_queryindex_allpixels, rtlight_t::corona_queryindex_visiblepixels, rtlight_t::corona_visibility, rtlight_t::coronasizescale, rtlight_t::flags, GL_BlendFunc(), GL_ColorMask(), GL_CullFace(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), gl_flashblend, GL_NONE, GL_ONE, GL_PolygonOffset(), GL_ZERO, viddef_support_t::glversion, i, identitymatrix, int(), cvar_t::integer, LIGHTFLAG_NORMALMODE, LIGHTFLAG_REALTIMEMODE, r_refdef_scene_t::lights, MAX_OCCLUSION_QUERIES, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), min, r_refdef_scene_t::numlights, R_BeginCoronaQuery(), r_coronas, r_coronas_occlusionquery, r_coronas_occlusionsizescale, R_DrawCorona(), R_EntityMatrix(), r_fb, r_maxqueries, R_Mesh_ResetTextureState(), r_numqueries, r_queries, r_refdef, R_SetupShader_Generic_NoTexture(), r_shadow_debuglight, r_shadow_worldlightsarray, rtlight_t::radius, r_waterstate_t::renderingscene, viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, RSurf_ActiveModelEntity(), dlight_t::rtlight, r_refdef_scene_t::rtworld, r_refdef_t::scene, viddef_t::support, cvar_t::value, vid, r_refdef_t::view, r_framebufferstate_t::water, and r_refdef_scene_t::worldentity.

Referenced by R_RenderScene().

R_Shadow_DrawLights()

void R_Shadow_DrawLights

(

void

)

Definition at line 4226 of file r_shadow.c.

{
    int lnum;
 
    R_Shadow_RenderMode_Begin();
 
    for (lnum = 0; lnum < r_shadow_scenenumlights; lnum++)
        R_Shadow_DrawLight(r_shadow_scenelightlist[lnum]);
 
    R_Shadow_RenderMode_End();
}

References R_Shadow_DrawLight(), R_Shadow_RenderMode_Begin(), R_Shadow_RenderMode_End(), r_shadow_scenelightlist, and r_shadow_scenenumlights.

Referenced by R_RenderScene().

R_Shadow_DrawPrepass()

void R_Shadow_DrawPrepass

(

void

)

Definition at line 3958 of file r_shadow.c.

{
    int i;
    int lnum;
    entity_render_t *ent;
    float clearcolor[4];
 
    R_Mesh_ResetTextureState();
    GL_DepthMask(true);
    GL_ColorMask(1,1,1,1);
    GL_BlendFunc(GL_ONE, GL_ZERO);
    GL_Color(1,1,1,1);
    GL_DepthTest(true);
    R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo);
    Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
    GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
    if (r_timereport_active)
        R_TimeReport("prepasscleargeom");
 
    if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
        r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
    if (r_timereport_active)
        R_TimeReport("prepassworld");
 
    for (i = 0;i < r_refdef.scene.numentities;i++)
    {
        if (!r_refdef.viewcache.entityvisible[i])
            continue;
        ent = r_refdef.scene.entities[i];
        if (ent->model && ent->model->DrawPrepass != NULL)
            ent->model->DrawPrepass(ent);
    }
 
    if (r_timereport_active)
        R_TimeReport("prepassmodels");
 
    GL_DepthMask(false);
    GL_ColorMask(1,1,1,1);
    GL_Color(1,1,1,1);
    GL_DepthTest(true);
    R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo);
    Vector4Set(clearcolor, 0, 0, 0, 0);
    GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
    if (r_timereport_active)
        R_TimeReport("prepassclearlit");
 
    R_Shadow_RenderMode_Begin();
 
    for (lnum = 0; lnum < r_shadow_scenenumlights; lnum++)
        R_Shadow_DrawLight(r_shadow_scenelightlist[lnum]);
 
    R_Shadow_RenderMode_End();
 
    if (r_timereport_active)
        R_TimeReport("prepasslights");
}

References cl, client_state_t::csqc_vidvars, model_t::DrawPrepass, csqc_vidvars_t::drawworld, r_refdef_scene_t::entities, r_refdef_viewcache_t::entityvisible, GL_BlendFunc(), GL_Clear(), GL_Color(), GL_COLOR_BUFFER_BIT, GL_ColorMask(), GL_DEPTH_BUFFER_BIT, GL_DepthMask(), GL_DepthTest(), GL_ONE, GL_ZERO, i, entity_render_t::model, NULL, r_refdef_scene_t::numentities, R_Mesh_ResetTextureState(), R_Mesh_SetRenderTargets(), r_refdef, R_Shadow_DrawLight(), r_shadow_prepassgeometryfbo, r_shadow_prepasslightingdiffusespecularfbo, R_Shadow_RenderMode_Begin(), R_Shadow_RenderMode_End(), r_shadow_scenelightlist, r_shadow_scenenumlights, R_TimeReport(), r_timereport_active, r_refdef_t::scene, Vector4Set, r_refdef_t::viewcache, r_refdef_scene_t::worldentity, and r_refdef_scene_t::worldmodel.

Referenced by R_RenderScene().

R_Shadow_DrawShadowMaps()

void R_Shadow_DrawShadowMaps

(

void

)

Definition at line 4204 of file r_shadow.c.

{
    R_Shadow_RenderMode_Begin();
    R_Shadow_RenderMode_ActiveLight(NULL);
 
    // now that we have a layout of shadowmaps in the atlas, we can render the shadowmaps
    R_Shadow_ClearShadowMapTexture();
 
    // render model shadowmaps (r_shadows 2) if desired which will be sampled in the forward pass
    if (r_shadow_shadowmapatlas_modelshadows_size)
        R_Shadow_DrawModelShadowMaps();
 
    if (R_Shadow_ShadowMappingEnabled())
    {
        int lnum;
        for (lnum = 0; lnum < r_shadow_scenenumlights; lnum++)
            R_Shadow_DrawLightShadowMaps(r_shadow_scenelightlist[lnum]);
    }
 
    R_Shadow_RenderMode_End();
}

References NULL, R_Shadow_ClearShadowMapTexture(), R_Shadow_DrawLightShadowMaps(), R_Shadow_DrawModelShadowMaps(), R_Shadow_RenderMode_ActiveLight(), R_Shadow_RenderMode_Begin(), R_Shadow_RenderMode_End(), r_shadow_scenelightlist, r_shadow_scenenumlights, r_shadow_shadowmapatlas_modelshadows_size, and R_Shadow_ShadowMappingEnabled().

Referenced by R_RenderScene().

R_Shadow_Init()

void R_Shadow_Init

(

void

)

Definition at line 601 of file r_shadow.c.

{
    Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
    Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
    Cvar_RegisterVariable(&r_shadow_usebihculling);
    Cvar_RegisterVariable(&r_shadow_usenormalmap);
    Cvar_RegisterVariable(&r_shadow_debuglight);
    Cvar_RegisterVariable(&r_shadow_deferred);
    Cvar_RegisterVariable(&r_shadow_gloss);
    Cvar_RegisterVariable(&r_shadow_gloss2intensity);
    Cvar_RegisterVariable(&r_shadow_glossintensity);
    Cvar_RegisterVariable(&r_shadow_glossexponent);
    Cvar_RegisterVariable(&r_shadow_gloss2exponent);
    Cvar_RegisterVariable(&r_shadow_glossexact);
    Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
    Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
    Cvar_RegisterVariable(&r_shadow_lightintensityscale);
    Cvar_RegisterVariable(&r_shadow_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_projectdistance);
    Cvar_RegisterVariable(&r_shadow_frontsidecasting);
    Cvar_RegisterVariable(&r_shadow_realtime_world_importlightentitiesfrommap);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
    Cvar_RegisterVariable(&r_shadow_realtime_world);
    Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
    Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
    Cvar_RegisterVariable(&r_shadow_scissor);
    Cvar_RegisterVariable(&r_shadow_shadowmapping);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_useshadowsampler);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_texturesize);
//  Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
//  Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
    Cvar_RegisterVariable(&r_shadow_sortsurfaces);
    Cvar_RegisterVariable(&r_shadow_culllights_pvs);
    Cvar_RegisterVariable(&r_shadow_culllights_trace);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_eyejitter);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_enlarge);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_expand);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_pad);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_samples);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_tempsamples);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_delay);
    Cvar_RegisterVariable(&r_shadow_bouncegrid);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_blur);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_bounceminimumintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_culllightpaths);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_directionalshading);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_dlightparticlemultiplier);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_hitmodels);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxbounce);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxphotons);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_quality);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_spacing);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_updateinterval);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_x);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_y);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_z);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_floatcolors);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_lightpathsize);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_normalizevectors);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_seed);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_type);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_bounceminimumintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxphotons);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_quality);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_spacing);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_subsamples);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_threaded);
    Cvar_RegisterVariable(&r_coronas);
    Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
    Cvar_RegisterVariable(&r_coronas_occlusionquery);
    Cvar_RegisterVariable(&gl_flashblend);
    R_Shadow_EditLights_Init();
    Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
    r_shadow_scenemaxlights = 0;
    r_shadow_scenenumlights = 0;
    r_shadow_scenelightlist = NULL;
    maxshadowtriangles = 0;
    shadowelements = NULL;
    maxshadowvertices = 0;
    shadowvertex3f = NULL;
    maxvertexupdate = 0;
    vertexupdate = NULL;
    vertexremap = NULL;
    vertexupdatenum = 0;
    maxshadowmark = 0;
    numshadowmark = 0;
    shadowmark = NULL;
    shadowmarklist = NULL;
    shadowmarkcount = 0;
    maxshadowsides = 0;
    numshadowsides = 0;
    shadowsides = NULL;
    shadowsideslist = NULL;
    r_shadow_buffer_numleafpvsbytes = 0;
    r_shadow_buffer_visitingleafpvs = NULL;
    r_shadow_buffer_leafpvs = NULL;
    r_shadow_buffer_leaflist = NULL;
    r_shadow_buffer_numsurfacepvsbytes = 0;
    r_shadow_buffer_surfacepvs = NULL;
    r_shadow_buffer_surfacelist = NULL;
    r_shadow_buffer_surfacesides = NULL;
    r_shadow_buffer_shadowtrispvs = NULL;
    r_shadow_buffer_lighttrispvs = NULL;
    R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
}

R_Shadow_PrepareLights()

void R_Shadow_PrepareLights

(

void

)

Definition at line 4031 of file r_shadow.c.

{
    int flag;
    int lnum;
    size_t lightindex;
    dlight_t *light;
    size_t range;
    float f;
 
    int shadowmapborder = bound(1, r_shadow_shadowmapping_bordersize.integer, 16);
    int shadowmaptexturesize = bound(256, r_shadow_shadowmapping_texturesize.integer, (int)vid.maxtexturesize_2d);
    int shadowmapmaxsize = bound(shadowmapborder+2, r_shadow_shadowmapping_maxsize.integer, shadowmaptexturesize / 8);
 
    if (r_shadow_shadowmode_shadowmapping != r_shadow_shadowmapping.integer ||
        r_shadow_shadowmode_deferred != r_shadow_deferred.integer ||
        r_shadow_shadowmaptexturesize != shadowmaptexturesize ||
        r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL32) ||
        r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
        r_shadow_shadowmapshadowsampler != r_shadow_shadowmapping_useshadowsampler.integer ||
        r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
        r_shadow_shadowmapborder != shadowmapborder ||
        r_shadow_shadowmapmaxsize != shadowmapmaxsize ||
        r_shadow_shadowmapdepthtexture != r_fb.usedepthtextures)
        R_Shadow_FreeShadowMaps();
 
    r_shadow_usingshadowmaportho = false;
 
    switch (vid.renderpath)
    {
    case RENDERPATH_GL32:
#ifndef USE_GLES2
        if (!r_shadow_deferred.integer || vid.maxdrawbuffers < 2)
        {
            r_shadow_usingdeferredprepass = false;
            if (r_shadow_prepass_width)
                R_Shadow_FreeDeferred();
            r_shadow_prepass_width = r_shadow_prepass_height = 0;
            break;
        }
 
        if (r_shadow_prepass_width != r_fb.screentexturewidth || r_shadow_prepass_height != r_fb.screentextureheight)
        {
            R_Shadow_FreeDeferred();
 
            r_shadow_usingdeferredprepass = true;
            r_shadow_prepass_width = r_fb.screentexturewidth;
            r_shadow_prepass_height = r_fb.screentextureheight;
            r_shadow_prepassgeometrydepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "prepassgeometrydepthbuffer", r_fb.screentexturewidth, r_fb.screentextureheight, TEXTYPE_DEPTHBUFFER24);
            r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, TEXTYPE_COLORBUFFER32F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
            r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
            r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
 
            // set up the geometry pass fbo (depth + normalmap)
            r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
            R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo);
            // render depth into a renderbuffer and other important properties into the normalmap texture
 
            // set up the lighting pass fbo (diffuse + specular)
            r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
            R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo);
            // render diffuse into one texture and specular into another,
            // with depth and normalmap bound as textures,
            // with depth bound as attachment as well
 
            // set up the lighting pass fbo (diffuse)
            r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
            R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo);
            // render diffuse into one texture,
            // with depth and normalmap bound as textures,
            // with depth bound as attachment as well
        }
#endif
        break;
    case RENDERPATH_GLES2:
        r_shadow_usingdeferredprepass = false;
        break;
    }
 
    R_Shadow_EnlargeLeafSurfaceTrisBuffer(r_refdef.scene.worldmodel->brush.num_leafs, r_refdef.scene.worldmodel->num_surfaces, r_refdef.scene.worldmodel->surfmesh.num_triangles, r_refdef.scene.worldmodel->surfmesh.num_triangles);
 
    r_shadow_scenenumlights = 0;
    flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
    range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
    for (lightindex = 0; lightindex < range; lightindex++)
    {
        light = (dlight_t *)Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
        if (light && (light->flags & flag))
        {
            R_Shadow_PrepareLight(&light->rtlight);
            R_Shadow_PrepareLights_AddSceneLight(&light->rtlight);
        }
    }
    if (r_refdef.scene.rtdlight)
    {
        for (lnum = 0; lnum < r_refdef.scene.numlights; lnum++)
        {
            R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
            R_Shadow_PrepareLights_AddSceneLight(r_refdef.scene.lights[lnum]);
        }
    }
    else if (gl_flashblend.integer)
    {
        for (lnum = 0; lnum < r_refdef.scene.numlights; lnum++)
        {
            rtlight_t *rtlight = r_refdef.scene.lights[lnum];
            f = ((rtlight->style >= 0 && rtlight->style < MAX_LIGHTSTYLES) ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
            VectorScale(rtlight->color, f, rtlight->currentcolor);
        }
    }
 
    // when debugging a single light, we still want to run the prepare, so we only replace the light list afterward...
    if (r_shadow_debuglight.integer >= 0)
    {
        r_shadow_scenenumlights = 0;
        lightindex = r_shadow_debuglight.integer;
        light = (dlight_t *)Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
        if (light)
        {
            R_Shadow_PrepareLight(&light->rtlight);
            R_Shadow_PrepareLights_AddSceneLight(&light->rtlight);
        }
    }
 
    // if we're doing shadowmaps we need to prepare the atlas layout now
    if (R_Shadow_ShadowMappingEnabled())
    {
        int lod;
 
        // allocate shadowmaps in the atlas now
        // we may have to make multiple attempts to fit the shadowmaps in the limited space of the atlas, this will appear as lod popping of all shadowmaps whenever it changes, but at least we can still cast shadows from all lights...
        for (lod = 0; lod < 16; lod++)
        {
            int packing_success = 0;
            int packing_failure = 0;
            Mod_AllocLightmap_Reset(&r_shadow_shadowmapatlas_state);
            // we actually have to reserve space for the R_DrawModelShadowMaps if that feature is active, it uses 0,0 so this is easy.
            if (r_shadow_shadowmapatlas_modelshadows_size)
                Mod_AllocLightmap_Block(&r_shadow_shadowmapatlas_state, r_shadow_shadowmapatlas_modelshadows_size, r_shadow_shadowmapatlas_modelshadows_size, &r_shadow_shadowmapatlas_modelshadows_x, &r_shadow_shadowmapatlas_modelshadows_y);
            for (lnum = 0; lnum < r_shadow_scenenumlights; lnum++)
            {
                rtlight_t *rtlight = r_shadow_scenelightlist[lnum];
                int size = rtlight->shadowmapsidesize >> lod;
                int width, height;
                if (!rtlight->castshadows)
                    continue;
                size = bound(r_shadow_shadowmapborder, size, r_shadow_shadowmaptexturesize);
                width = size * 2;
                height = size * 3;
                // when there are noselfshadow entities in the light bounds, we have to render two separate sets of shadowmaps :(
                if (rtlight->cached_numshadowentities_noselfshadow)
                    width *= 2;
                if (Mod_AllocLightmap_Block(&r_shadow_shadowmapatlas_state, width, height, &rtlight->shadowmapatlasposition[0], &rtlight->shadowmapatlasposition[1]))
                {
                    rtlight->shadowmapatlassidesize = size;
                    packing_success++;
                }
                else
                {
                    // note down that we failed to pack this one, it will have to disable shadows
                    rtlight->shadowmapatlassidesize = 0;
                    packing_failure++;
                }
            }
            // generally everything fits and we stop here on the first iteration
            if (packing_failure == 0)
                break;
        }
    }
 
    if (r_editlights.integer)
        R_Shadow_DrawLightSprites();
}

References bound, model_t::brush, rtlight_t::cached_numshadowentities_noselfshadow, rtlight_t::castshadows, rtlight_t::color, rtlight_t::currentcolor, f, dlight_t::flags, gl_flashblend, height, cvar_t::integer, LIGHTFLAG_NORMALMODE, LIGHTFLAG_REALTIMEMODE, r_refdef_scene_t::lights, r_refdef_scene_t::lightstylevalue, lod, MAX_LIGHTSTYLES, viddef_t::maxdrawbuffers, viddef_t::maxtexturesize_2d, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), Mod_AllocLightmap_Block(), Mod_AllocLightmap_Reset(), NULL, model_brush_t::num_leafs, model_t::num_surfaces, surfmesh_t::num_triangles, r_refdef_scene_t::numlights, r_editlights, r_fb, R_LoadTexture2D(), R_LoadTextureRenderBuffer(), R_Mesh_CreateFramebufferObject(), R_Mesh_SetRenderTargets(), r_refdef, r_shadow_debuglight, r_shadow_deferred, R_Shadow_DrawLightSprites(), R_Shadow_EnlargeLeafSurfaceTrisBuffer(), R_Shadow_FreeDeferred(), R_Shadow_FreeShadowMaps(), r_shadow_lightintensityscale, R_Shadow_PrepareLight(), R_Shadow_PrepareLights_AddSceneLight(), r_shadow_prepass_height, r_shadow_prepass_width, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepasslightingdiffusefbo, r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, r_shadow_scenelightlist, r_shadow_scenenumlights, r_shadow_shadowmapatlas_modelshadows_size, r_shadow_shadowmapatlas_modelshadows_x, r_shadow_shadowmapatlas_modelshadows_y, r_shadow_shadowmapatlas_state, r_shadow_shadowmapborder, r_shadow_shadowmapdepthbits, r_shadow_shadowmapdepthtexture, r_shadow_shadowmapfilterquality, r_shadow_shadowmapmaxsize, r_shadow_shadowmapping, r_shadow_shadowmapping_bordersize, r_shadow_shadowmapping_depthbits, r_shadow_shadowmapping_filterquality, r_shadow_shadowmapping_maxsize, r_shadow_shadowmapping_texturesize, r_shadow_shadowmapping_useshadowsampler, r_shadow_shadowmapping_vsdct, R_Shadow_ShadowMappingEnabled(), r_shadow_shadowmapshadowsampler, r_shadow_shadowmaptexturesize, r_shadow_shadowmapvsdct, r_shadow_shadowmode_deferred, r_shadow_shadowmode_shadowmapping, r_shadow_texturepool, r_shadow_usingdeferredprepass, r_shadow_usingshadowmaportho, r_shadow_worldlightsarray, viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, r_refdef_scene_t::rtdlight, dlight_t::rtlight, r_refdef_scene_t::rtworld, r_refdef_t::scene, r_framebufferstate_t::screentextureheight, r_framebufferstate_t::screentexturewidth, rtlight_t::shadowmapatlasposition, rtlight_t::shadowmapatlassidesize, rtlight_t::shadowmapsidesize, size, rtlight_t::style, model_t::surfmesh, TEXF_ALPHA, TEXF_CLAMP, TEXF_FORCENEAREST, TEXF_RENDERTARGET, TEXTYPE_COLORBUFFER16F, TEXTYPE_COLORBUFFER32F, TEXTYPE_DEPTHBUFFER24, r_framebufferstate_t::usedepthtextures, cvar_t::value, VectorScale, vid, width, and r_refdef_scene_t::worldmodel.

Referenced by R_RenderScene().

R_Shadow_PrepareModelShadows()

void R_Shadow_PrepareModelShadows

(

void

)

Definition at line 4242 of file r_shadow.c.

{
    int i;
    float scale, size, radius, dot1, dot2;
    prvm_vec3_t prvmshadowdir, prvmshadowfocus;
    vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
    entity_render_t *ent;
 
    r_shadow_nummodelshadows = 0;
    r_shadow_shadowmapatlas_modelshadows_size = 0;
 
    if (!r_refdef.scene.numentities || r_refdef.scene.lightmapintensity <= 0.0f || r_shadows.integer <= 0)
        return;
 
    size = r_shadow_shadowmaptexturesize / 4;
    scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
    radius = 0.5f * size / scale;
 
    Math_atov(r_shadows_throwdirection.string, prvmshadowdir);
    VectorCopy(prvmshadowdir, shadowdir);
    VectorNormalize(shadowdir);
    dot1 = DotProduct(r_refdef.view.forward, shadowdir);
    dot2 = DotProduct(r_refdef.view.up, shadowdir);
    if (fabs(dot1) <= fabs(dot2))
        VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
    else
        VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
    VectorNormalize(shadowforward);
    CrossProduct(shadowdir, shadowforward, shadowright);
    Math_atov(r_shadows_focus.string, prvmshadowfocus);
    VectorCopy(prvmshadowfocus, shadowfocus);
    VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
    VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
    VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
    VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
    if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
        dot1 = 1;
    VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
 
    shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
    shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
    shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
    shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
    shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
    shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
 
    for (i = 0; i < r_refdef.scene.numentities; i++)
    {
        ent = r_refdef.scene.entities[i];
        if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
            continue;
        // cast shadows from anything of the map (submodels are optional)
        if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
        {
            if (r_shadow_nummodelshadows >= MAX_MODELSHADOWS)
                break;
            r_shadow_modelshadows[r_shadow_nummodelshadows++] = ent;
            R_AnimCache_GetEntity(ent, false, false);
        }
    }
 
    if (r_shadow_nummodelshadows)
    {
        r_shadow_shadowmapatlas_modelshadows_x = 0;
        r_shadow_shadowmapatlas_modelshadows_y = 0;
        r_shadow_shadowmapatlas_modelshadows_size = size;
    }
}

References BoxesOverlap, model_t::brush, CrossProduct, DotProduct, model_t::DrawShadowMap, r_refdef_scene_t::entities, fabs(), entity_render_t::flags, r_refdef_view_t::forward, i, cvar_t::integer, r_refdef_scene_t::lightmapintensity, Math_atov(), MAX_MODELSHADOWS, entity_render_t::maxs, entity_render_t::mins, entity_render_t::model, NULL, r_refdef_scene_t::numentities, r_refdef_view_t::origin, R_AnimCache_GetEntity(), r_refdef, r_shadow_modelshadows, r_shadow_nummodelshadows, r_shadow_shadowmapatlas_modelshadows_size, r_shadow_shadowmapatlas_modelshadows_x, r_shadow_shadowmapatlas_modelshadows_y, r_shadow_shadowmapping_precision, r_shadow_shadowmaptexturesize, r_shadows, r_shadows_castfrombmodels, r_shadows_focus, r_shadows_shadowmapscale, r_shadows_throwdirection, r_shadows_throwdistance, RENDER_SHADOW, r_refdef_view_t::right, scale, r_refdef_t::scene, size, cvar_t::string, model_brush_t::submodel, r_refdef_view_t::up, cvar_t::value, VectorAdd, VectorCopy, VectorM, VectorMA, VectorNormalize, and r_refdef_t::view.

Referenced by R_RenderScene().

R_Shadow_PrepareShadowMark()

void R_Shadow_PrepareShadowMark

(

int

numtris

)

Definition at line 824 of file r_shadow.c.

{
    // make sure shadowmark is big enough for this volume
    if (maxshadowmark < numtris)
    {
        maxshadowmark = numtris;
        if (shadowmark)
            Mem_Free(shadowmark);
        if (shadowmarklist)
            Mem_Free(shadowmarklist);
        shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
        shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
        shadowmarkcount = 0;
    }
    shadowmarkcount++;
    // if shadowmarkcount wrapped we clear the array and adjust accordingly
    if (shadowmarkcount == 0)
    {
        shadowmarkcount = 1;
        memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
    }
    numshadowmark = 0;
}

References maxshadowmark, Mem_Alloc, Mem_Free, numshadowmark, r_main_mempool, shadowmark, shadowmarkcount, and shadowmarklist.

R_Shadow_PrepareShadowSides()

void R_Shadow_PrepareShadowSides

(

int

numtris

)

Definition at line 848 of file r_shadow.c.

{
    if (maxshadowsides < numtris)
    {
        maxshadowsides = numtris;
        if (shadowsides)
            Mem_Free(shadowsides);
        if (shadowsideslist)
            Mem_Free(shadowsideslist);
        shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
        shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
    }
    numshadowsides = 0;
}

References maxshadowsides, Mem_Alloc, Mem_Free, numshadowsides, r_main_mempool, shadowsides, and shadowsideslist.

Referenced by R_Mod_CompileShadowMap().

R_Shadow_RenderLighting()

void R_Shadow_RenderLighting	(	int	texturenumsurfaces,
		const struct msurface_s **	texturesurfacelist )

R_Shadow_RenderMode_ActiveLight()

void R_Shadow_RenderMode_ActiveLight

(

const struct rtlight_s *

rtlight

)

R_Shadow_RenderMode_Begin()

void R_Shadow_RenderMode_Begin

(

void

)

Definition at line 1369 of file r_shadow.c.

{
#if 0
    GLint drawbuffer;
    GLint readbuffer;
#endif
 
    if (r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
     || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
        R_Shadow_MakeTextures();
 
    CHECKGLERROR
    R_Mesh_ResetTextureState();
    GL_BlendFunc(GL_ONE, GL_ZERO);
    GL_DepthRange(0, 1);
    GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
    GL_DepthTest(true);
    GL_DepthMask(false);
    GL_Color(0, 0, 0, 1);
    GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
    
    r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
    r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
 
    CHECKGLERROR
#if 0
    qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
    qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
    r_shadow_drawbuffer = drawbuffer;
    r_shadow_readbuffer = readbuffer;
#endif
    r_shadow_cullface_front = r_refdef.view.cullface_front;
    r_shadow_cullface_back = r_refdef.view.cullface_back;
}

References CHECKGLERROR, r_refdef_view_t::cullface_back, r_refdef_view_t::cullface_front, GL_BlendFunc(), GL_Color(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), GL_DRAW_BUFFER, GL_ONE, GL_PolygonOffset(), GL_READ_BUFFER, GL_Scissor(), GL_ZERO, r_viewport_t::height, r_refdef_t::polygonfactor, r_refdef_t::polygonoffset, R_Mesh_ResetTextureState(), r_refdef, r_shadow_attendividebias, r_shadow_attenlinearscale, r_shadow_cullface_back, r_shadow_cullface_front, r_shadow_lightattenuationdividebias, r_shadow_lightattenuationlinearscale, r_shadow_lightingrendermode, R_Shadow_MakeTextures(), r_shadow_rendermode, R_SHADOW_RENDERMODE_LIGHT_GLSL, R_SHADOW_RENDERMODE_NONE, cvar_t::value, r_refdef_t::view, r_refdef_view_t::viewport, r_viewport_t::width, r_viewport_t::x, and r_viewport_t::y.

Referenced by R_Q1BSP_DrawLight_TransparentCallback(), R_Shadow_DrawLights(), R_Shadow_DrawPrepass(), and R_Shadow_DrawShadowMaps().

R_Shadow_RenderMode_DrawDeferredLight()

void R_Shadow_RenderMode_DrawDeferredLight

(

qbool

shadowmapping

)

Definition at line 1642 of file r_shadow.c.

{
    int i;
    float vertex3f[8*3];
    const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
// do global setup needed for the chosen lighting mode
    R_Shadow_RenderMode_Reset();
    r_shadow_rendermode = r_shadow_lightingrendermode;
    R_EntityMatrix(&identitymatrix);
    GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
    if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
        R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo);
    else
        R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo);
 
    r_shadow_usingshadowmap2d = shadowmapping;
 
    // render the lighting
    R_SetupShader_DeferredLight(rsurface.rtlight);
    for (i = 0;i < 8;i++)
        Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
    GL_ColorMask(1,1,1,1);
    GL_DepthMask(false);
    GL_DepthRange(0, 1);
    GL_PolygonOffset(0, 0);
    GL_DepthTest(true);
    GL_DepthFunc(GL_GREATER);
    GL_CullFace(r_refdef.view.cullface_back);
    R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL, 0);
    R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
}

References bboxelements, bboxpoints, r_refdef_view_t::cullface_back, GL_BlendFunc(), GL_ColorMask(), GL_CullFace(), GL_DepthFunc(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), GL_GREATER, GL_ONE, GL_PolygonOffset(), GL_SRC_ALPHA, i, identitymatrix, cvar_t::integer, Matrix4x4_Transform(), rtlight_t::matrix_lighttoworld, NULL, R_EntityMatrix(), R_Mesh_Draw(), R_Mesh_PrepareVertices_Vertex3f(), R_Mesh_SetRenderTargets(), r_refdef, R_SetupShader_DeferredLight(), r_shadow_gloss, r_shadow_lightingrendermode, r_shadow_prepasslightingdiffusefbo, r_shadow_prepasslightingdiffusespecularfbo, r_shadow_rendermode, R_Shadow_RenderMode_Reset(), r_shadow_usingshadowmap2d, rsurface, rsurfacestate_t::rtlight, rtlight_t::specularscale, and r_refdef_t::view.

Referenced by R_Shadow_DrawLight().

R_Shadow_RenderMode_End()

void R_Shadow_RenderMode_End

(

void

)

Definition at line 2872 of file r_shadow.c.

{
    R_Shadow_RenderMode_Reset();
    R_Shadow_RenderMode_ActiveLight(NULL);
    GL_DepthMask(true);
    GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
    r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
}

References GL_DepthMask(), GL_Scissor(), r_viewport_t::height, NULL, r_refdef, r_shadow_rendermode, R_Shadow_RenderMode_ActiveLight(), R_SHADOW_RENDERMODE_NONE, R_Shadow_RenderMode_Reset(), r_refdef_t::view, r_refdef_view_t::viewport, r_viewport_t::width, r_viewport_t::x, and r_viewport_t::y.

Referenced by R_Q1BSP_DrawLight_TransparentCallback(), R_Shadow_DrawLights(), R_Shadow_DrawPrepass(), and R_Shadow_DrawShadowMaps().

R_Shadow_RenderMode_Lighting()

void R_Shadow_RenderMode_Lighting	(	qbool	transparent,
		qbool	shadowmapping,
		qbool	noselfshadowpass )

Definition at line 1597 of file r_shadow.c.

{
    R_Mesh_ResetTextureState();
    if (transparent)
    {
        r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
        r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
        r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
        r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
    }
    if (shadowmapping)
        R_Shadow_SetShadowmapParametersForLight(noselfshadowpass);
    R_Shadow_RenderMode_Reset();
    GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
    if (!transparent)
        GL_DepthFunc(GL_EQUAL);
    // do global setup needed for the chosen lighting mode
    if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
        GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
    r_shadow_usingshadowmap2d = shadowmapping;
    r_shadow_rendermode = r_shadow_lightingrendermode;
}

References r_refdef_view_t::colormask, GL_BlendFunc(), GL_ColorMask(), GL_DepthFunc(), GL_EQUAL, GL_ONE, GL_SRC_ALPHA, r_viewport_t::height, R_Mesh_ResetTextureState(), r_refdef, r_shadow_lightingrendermode, r_shadow_lightscissor, r_shadow_rendermode, R_SHADOW_RENDERMODE_LIGHT_GLSL, R_Shadow_RenderMode_Reset(), R_Shadow_SetShadowmapParametersForLight(), r_shadow_usingshadowmap2d, r_refdef_t::view, r_refdef_view_t::viewport, r_viewport_t::width, r_viewport_t::x, and r_viewport_t::y.

Referenced by R_Q1BSP_DrawLight_TransparentCallback(), and R_Shadow_DrawLight().

R_Shadow_RenderMode_Reset()

void R_Shadow_RenderMode_Reset

(

void

)

Definition at line 1409 of file r_shadow.c.

{
    R_Mesh_ResetTextureState();
    R_Mesh_SetRenderTargets(r_shadow_viewfbo);
    R_SetViewport(&r_refdef.view.viewport);
    GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
    GL_DepthRange(0, 1);
    GL_DepthTest(true);
    GL_DepthMask(false);
    GL_DepthFunc(GL_LEQUAL);
    GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
    r_refdef.view.cullface_front = r_shadow_cullface_front;
    r_refdef.view.cullface_back = r_shadow_cullface_back;
    GL_CullFace(r_refdef.view.cullface_back);
    GL_Color(1, 1, 1, 1);
    GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
    GL_BlendFunc(GL_ONE, GL_ZERO);
    R_SetupShader_Generic_NoTexture(false, false);
    r_shadow_usingshadowmap2d = false;
}

References CHECKGLERROR, r_refdef_view_t::colormask, r_refdef_view_t::cullface_back, r_refdef_view_t::cullface_front, GL_BlendFunc(), GL_Color(), GL_ColorMask(), GL_CullFace(), GL_DepthFunc(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), GL_LEQUAL, GL_ONE, GL_PolygonOffset(), GL_Scissor(), GL_ZERO, r_refdef_t::polygonfactor, r_refdef_t::polygonoffset, R_Mesh_ResetTextureState(), R_Mesh_SetRenderTargets(), r_refdef, R_SetupShader_Generic_NoTexture(), R_SetViewport(), r_shadow_cullface_back, r_shadow_cullface_front, r_shadow_lightscissor, r_shadow_usingshadowmap2d, r_shadow_viewfbo, r_refdef_t::view, and r_refdef_view_t::viewport.

Referenced by R_Shadow_ClearShadowMapTexture(), R_Shadow_RenderMode_DrawDeferredLight(), R_Shadow_RenderMode_End(), R_Shadow_RenderMode_Lighting(), R_Shadow_RenderMode_ShadowMap(), and R_Shadow_RenderMode_VisibleLighting().

R_Shadow_RenderMode_VisibleLighting()

void R_Shadow_RenderMode_VisibleLighting

(

qbool

transparent

)

Definition at line 2860 of file r_shadow.c.

{
    R_Shadow_RenderMode_Reset();
    GL_BlendFunc(GL_ONE, GL_ONE);
    GL_DepthRange(0, 1);
    GL_DepthTest(r_showlighting.integer < 2);
    GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
    if (!transparent)
        GL_DepthFunc(GL_EQUAL);
    r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
}

References r_refdef_view_t::colorscale, GL_BlendFunc(), GL_Color(), GL_DepthFunc(), GL_DepthRange(), GL_DepthTest(), GL_EQUAL, GL_ONE, cvar_t::integer, r_refdef, r_shadow_rendermode, R_Shadow_RenderMode_Reset(), R_SHADOW_RENDERMODE_VISIBLELIGHTING, r_showlighting, and r_refdef_t::view.

Referenced by R_Shadow_DrawLight().

R_Shadow_ScissorForBBox()

qbool R_Shadow_ScissorForBBox	(	const float *	mins,
		const float *	maxs )

Definition at line 2900 of file r_shadow.c.

{
    if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
    {
        r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
        r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
        r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
        r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
        return false;
    }
    if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
        return true; // invisible
    if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
    || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
    || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
    || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
        r_refdef.stats[r_stat_lights_scissored]++;
    return false;
}

References r_viewport_t::height, cvar_t::integer, maxs, mins, r_refdef, R_ScissorForBBox(), r_shadow_lightscissor, r_shadow_scissor, r_shadow_usingdeferredprepass, r_stat_lights_scissored, r_trippy, r_refdef_t::stats, r_refdef_t::view, r_refdef_view_t::viewport, r_viewport_t::width, r_viewport_t::x, and r_viewport_t::y.

Referenced by R_Shadow_DrawLight(), and R_Shadow_DrawLightShadowMaps().

R_Shadow_SetupEntityLight()

void R_Shadow_SetupEntityLight

(

const struct entity_render_s *

ent

)

R_Shadow_ShadowMapFromList()

void R_Shadow_ShadowMapFromList	(	int	numverts,
		int	numtris,
		const float *	vertex3f,
		const int *	elements,
		int	numsidetris,
		const int *	sidetotals,
		const unsigned char *	sides,
		const int *	sidetris )

Definition at line 1162 of file r_shadow.c.

{
    int i, j, outtriangles = 0;
    int *outelement3i[6];
    if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
        return;
    outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
    // make sure shadowelements is big enough for this mesh
    if (maxshadowtriangles < outtriangles)
        R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
 
    // compute the offset and size of the separate index lists for each cubemap side
    outtriangles = 0;
    for (i = 0;i < 6;i++)
    {
        outelement3i[i] = shadowelements + outtriangles * 3;
        r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
        r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
        outtriangles += sidetotals[i];
    }
 
    // gather up the (sparse) triangles into separate index lists for each cubemap side
    for (i = 0;i < numsidetris;i++)
    {
        const int *element = elements + sidetris[i] * 3;
        for (j = 0;j < 6;j++)
        {
            if (sides[i] & (1 << j))
            {
                outelement3i[j][0] = element[0];
                outelement3i[j][1] = element[1];
                outelement3i[j][2] = element[2];
                outelement3i[j] += 3;
            }
        }
    }
 
    Mod_ShadowMesh_AddMesh(r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, vertex3f, outtriangles, shadowelements);
}

References i, maxshadowtriangles, Mod_ShadowMesh_AddMesh(), r_shadow_compilingrtlight, R_Shadow_ResizeShadowArrays(), shadowelements, shadowmesh_t::sideoffsets, shadowmesh_t::sidetotals, and rtlight_t::static_meshchain_shadow_shadowmap.

Referenced by R_Mod_CompileShadowMap().

R_Shadow_ShadowMappingEnabled()

qbool R_Shadow_ShadowMappingEnabled

(

void

)

Definition at line 378 of file r_shadow.c.

{
    switch (r_shadow_shadowmode)
    {
    case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
        return true;
    case R_SHADOW_SHADOWMODE_DISABLED:
        return false;
    }
    return false;
}

References r_shadow_shadowmode, R_SHADOW_SHADOWMODE_DISABLED, and R_SHADOW_SHADOWMODE_SHADOWMAP2D.

Referenced by R_RenderScene(), R_Shadow_DrawShadowMaps(), R_Shadow_PrepareLight(), and R_Shadow_PrepareLights().

R_Shadow_UpdateWorldLightSelection()

void R_Shadow_UpdateWorldLightSelection

(

void

)

Definition at line 5289 of file r_shadow.c.

{
    if (r_editlights.integer)
    {
        R_Shadow_SetCursorLocationForView();
        R_Shadow_SelectLightInView();
    }
    else
        R_Shadow_SelectLight(NULL);
}

References cvar_t::integer, NULL, r_editlights, R_Shadow_SelectLight(), R_Shadow_SelectLightInView(), and R_Shadow_SetCursorLocationForView().

Referenced by R_RenderView().

Variable Documentation

matrix_attenuationxyz

matrix4x4_t matrix_attenuationxyz

extern

Definition at line 734 of file r_shadow.c.

{
    {
        {0.5, 0.0, 0.0, 0.5},
        {0.0, 0.5, 0.0, 0.5},
        {0.0, 0.0, 0.5, 0.5},
        {0.0, 0.0, 0.0, 1.0}
    }
};

Referenced by R_Shadow_DrawWorldLight(), and R_Shadow_SetupEntityLight().

matrix_attenuationz

matrix4x4_t matrix_attenuationz

extern

Definition at line 744 of file r_shadow.c.

{
    {
        {0.0, 0.0, 0.5, 0.5},
        {0.0, 0.0, 0.0, 0.5},
        {0.0, 0.0, 0.0, 0.5},
        {0.0, 0.0, 0.0, 1.0}
    }
};

Referenced by R_Shadow_DrawWorldLight(), and R_Shadow_SetupEntityLight().

maxshadowmark

int maxshadowmark

extern

Definition at line 76 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowMark(), r_shadow_shutdown(), and r_shadow_start().

maxshadowsides

int maxshadowsides

extern

Definition at line 82 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowSides(), r_shadow_shutdown(), and r_shadow_start().

numshadowmark

int numshadowmark

extern

Definition at line 77 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowMark(), r_shadow_shutdown(), and r_shadow_start().

numshadowsides

int numshadowsides

extern

Definition at line 83 of file r_shadow.c.

Referenced by R_Mod_CompileShadowMap(), R_Shadow_ChooseSidesFromBox(), R_Shadow_Init(), R_Shadow_PrepareShadowSides(), r_shadow_shutdown(), and r_shadow_start().

r_shadow_bouncegrid_state

r_shadow_bouncegrid_state_t r_shadow_bouncegrid_state

extern

Definition at line 259 of file r_shadow.c.

Referenced by R_SetupShader_Surface(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_BlurPixels_Task(), R_Shadow_BounceGrid_BlurPixelsInDirection(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_ClearTex_Task(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), R_Shadow_BounceGrid_EnqueuePhotons_Task(), R_Shadow_BounceGrid_EnqueueSlices_Task(), R_Shadow_BounceGrid_FreeHighPixels(), R_Shadow_BounceGrid_GenerateSettings(), R_Shadow_BounceGrid_RefractiveIndexAtPoint(), R_Shadow_BounceGrid_Slice(), R_Shadow_BounceGrid_TracePhotons_Shot(), R_Shadow_BounceGrid_TracePhotons_ShotTask(), R_Shadow_BounceGrid_UpdateSpacing(), r_shadow_newmap(), r_shadow_shutdown(), r_shadow_start(), and R_Shadow_UpdateBounceGridTexture().

r_shadow_bumpscale_basetexture

struct cvar_s r_shadow_bumpscale_basetexture

extern

Definition at line 141 of file r_shadow.c.

{CF_CLIENT, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};

Referenced by R_Shadow_Init(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternalBGRA(), and R_SkinFrame_LoadInternalQuake().

r_shadow_bumpscale_bumpmap

struct cvar_s r_shadow_bumpscale_bumpmap

extern

Definition at line 142 of file r_shadow.c.

{CF_CLIENT, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};

Referenced by R_Shadow_Init(), and R_SkinFrame_LoadExternal_SkinFrame().

r_shadow_compilingrtlight

struct rtlight_s* r_shadow_compilingrtlight

extern

Definition at line 272 of file r_shadow.c.

Referenced by R_Mod_CompileShadowMap(), R_Mod_GetLightInfo(), R_Q1BSP_RecursiveGetLightInfo_BIH(), R_Q1BSP_RecursiveGetLightInfo_BSP(), R_RTLight_Compile(), and R_Shadow_ShadowMapFromList().

r_shadow_debuglight

struct cvar_s r_shadow_debuglight

extern

Definition at line 143 of file r_shadow.c.

{CF_CLIENT, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};

Referenced by R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_DrawCoronas(), R_Shadow_Init(), and R_Shadow_PrepareLights().

r_shadow_frontsidecasting

struct cvar_s r_shadow_frontsidecasting

extern

Definition at line 158 of file r_shadow.c.

{CF_CLIENT, "r_shadow_frontsidecasting", "1", "whether to cast shadows from illuminated triangles (front side of model) or unlit triangles (back side of model)"};

Referenced by R_Mod_GetLightInfo(), R_Shadow_ChooseSidesFromBox(), R_Shadow_Init(), and R_UpdateVariables().

r_shadow_gloss

struct cvar_s r_shadow_gloss

extern

Definition at line 147 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};

Referenced by R_Shadow_Init(), and R_Shadow_RenderMode_DrawDeferredLight().

r_shadow_gloss2exponent

struct cvar_s r_shadow_gloss2exponent

extern

Definition at line 151 of file r_shadow.c.

{CF_CLIENT, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};

Referenced by R_GetCurrentTexture(), R_SetupShader_DeferredLight(), and R_Shadow_Init().

r_shadow_gloss2intensity

struct cvar_s r_shadow_gloss2intensity

extern

Definition at line 148 of file r_shadow.c.

{CF_CLIENT, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};

Referenced by R_GetCurrentTexture(), and R_Shadow_Init().

r_shadow_glossexact

struct cvar_s r_shadow_glossexact

extern

Definition at line 152 of file r_shadow.c.

{CF_CLIENT, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};

Referenced by R_CompileShader_CheckStaticParms(), R_SetupShader_DeferredLight(), R_SetupShader_Surface(), and R_Shadow_Init().

r_shadow_glossexponent

struct cvar_s r_shadow_glossexponent

extern

Definition at line 150 of file r_shadow.c.

{CF_CLIENT, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};

Referenced by R_GetCurrentTexture(), R_SetupShader_DeferredLight(), and R_Shadow_Init().

r_shadow_glossintensity

struct cvar_s r_shadow_glossintensity

extern

Definition at line 149 of file r_shadow.c.

{CF_CLIENT, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};

Referenced by R_GetCurrentTexture(), and R_Shadow_Init().

r_shadow_lightattenuationpower

struct cvar_s r_shadow_lightattenuationpower

extern

r_shadow_lightattenuationscale

struct cvar_s r_shadow_lightattenuationscale

extern

r_shadow_lightintensityscale

struct cvar_s r_shadow_lightintensityscale

extern

Definition at line 155 of file r_shadow.c.

{CF_CLIENT, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};

Referenced by R_CompleteLightPoint(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_Init(), R_Shadow_PrepareLight(), and R_Shadow_PrepareLights().

r_shadow_lightradiusscale

struct cvar_s r_shadow_lightradiusscale

extern

Definition at line 156 of file r_shadow.c.

{CF_CLIENT, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};

Referenced by R_RTLight_Update(), and R_Shadow_Init().

r_shadow_projectdistance

struct cvar_s r_shadow_projectdistance

extern

Definition at line 157 of file r_shadow.c.

{CF_CLIENT, "r_shadow_projectdistance", "0", "how far to cast shadows"};

Referenced by R_Shadow_Init().

r_shadow_realtime_dlight

struct cvar_s r_shadow_realtime_dlight

extern

Definition at line 159 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};

Referenced by R_Shadow_Init().

r_shadow_realtime_dlight_portalculling

struct cvar_s r_shadow_realtime_dlight_portalculling

extern

Definition at line 162 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};

Referenced by R_Mod_GetLightInfo(), and R_Shadow_Init().

r_shadow_realtime_dlight_shadows

struct cvar_s r_shadow_realtime_dlight_shadows

extern

Definition at line 160 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};

Referenced by R_Shadow_Init().

r_shadow_realtime_dlight_svbspculling

struct cvar_s r_shadow_realtime_dlight_svbspculling

extern

Definition at line 161 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};

Referenced by R_Mod_GetLightInfo(), and R_Shadow_Init().

r_shadow_realtime_world

struct cvar_s r_shadow_realtime_world

extern

Definition at line 163 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"};

Referenced by R_Shadow_Init().

r_shadow_realtime_world_compile

struct cvar_s r_shadow_realtime_world_compile

extern

Definition at line 167 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};

Referenced by R_Shadow_DrawLightShadowMaps(), R_Shadow_DrawWorldShadow_ShadowMap(), R_Shadow_Init(), and R_Shadow_PrepareLight().

r_shadow_realtime_world_compileportalculling

struct cvar_s r_shadow_realtime_world_compileportalculling

extern

Definition at line 170 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};

Referenced by R_Mod_GetLightInfo(), and R_Shadow_Init().

r_shadow_realtime_world_compileshadow

struct cvar_s r_shadow_realtime_world_compileshadow

extern

Definition at line 168 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};

Referenced by R_Shadow_DrawLightShadowMaps(), R_Shadow_DrawWorldShadow_ShadowMap(), and R_Shadow_Init().

r_shadow_realtime_world_compilesvbsp

struct cvar_s r_shadow_realtime_world_compilesvbsp

extern

Definition at line 169 of file r_shadow.c.

{CF_CLIENT, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};

Referenced by R_Mod_GetLightInfo(), and R_Shadow_Init().

r_shadow_realtime_world_lightmaps

struct cvar_s r_shadow_realtime_world_lightmaps

extern

Definition at line 165 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};

Referenced by R_Shadow_Init().

r_shadow_realtime_world_shadows

struct cvar_s r_shadow_realtime_world_shadows

extern

Definition at line 166 of file r_shadow.c.

{CF_CLIENT | CF_ARCHIVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};

Referenced by R_Shadow_Init().

r_shadow_scissor

struct cvar_s r_shadow_scissor

extern

Definition at line 171 of file r_shadow.c.

{CF_CLIENT, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};

Referenced by R_Shadow_Init(), and R_Shadow_ScissorForBBox().

shadowmark

int* shadowmark

extern

Definition at line 78 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowMark(), r_shadow_shutdown(), and r_shadow_start().

shadowmarkcount

int shadowmarkcount

extern

Definition at line 80 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowMark(), r_shadow_shutdown(), and r_shadow_start().

shadowmarklist

int* shadowmarklist

extern

Definition at line 79 of file r_shadow.c.

Referenced by R_Shadow_Init(), R_Shadow_PrepareShadowMark(), r_shadow_shutdown(), and r_shadow_start().

shadowsides

unsigned char* shadowsides

extern

Definition at line 84 of file r_shadow.c.

Referenced by R_Mod_CompileShadowMap(), R_Shadow_ChooseSidesFromBox(), R_Shadow_Init(), R_Shadow_PrepareShadowSides(), r_shadow_shutdown(), and r_shadow_start().

shadowsideslist

int* shadowsideslist

extern

Definition at line 85 of file r_shadow.c.

Referenced by R_Mod_CompileShadowMap(), R_Shadow_ChooseSidesFromBox(), R_Shadow_Init(), R_Shadow_PrepareShadowSides(), r_shadow_shutdown(), and r_shadow_start().