cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"};
-cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "2", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
+cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "4", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
//cvar_t r_shadow_deferred_fp = {CVAR_SAVE, "r_shadow_deferred_fp", "0", "use 16bit (1) or 32bit (2) floating point for accumulation of image-based lighting"};
cvar_t r_shadow_usebihculling = {0, "r_shadow_usebihculling", "1", "use BIH (Bounding Interval Hierarchy) for culling lit surfaces instead of BSP (Binary Space Partitioning)"};
cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect OpenGL 2.0 render path)"};
-cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, requires r_shadow_realtime_world 1"};
+cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, only active on levels with realtime lights active (r_shadow_realtime_world is usually required for these)"};
cvar_t r_shadow_bouncegrid_bounceanglediffuse = {CVAR_SAVE, "r_shadow_bouncegrid_bounceanglediffuse", "0", "use random bounce direction rather than true reflection, makes some corner areas dark"};
+cvar_t r_shadow_bouncegrid_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_directionalshading", "0", "use diffuse shading rather than ambient, 3D texture becomes 4x as many pixels to hold the additional data"};
cvar_t r_shadow_bouncegrid_dlightparticlemultiplier = {CVAR_SAVE, "r_shadow_bouncegrid_dlightparticlemultiplier", "0", "if set to a high value like 16 this can make dlights look great, but 0 is recommended for performance reasons"};
cvar_t r_shadow_bouncegrid_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
-cvar_t r_shadow_bouncegrid_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_lightradiusscale", "2", "particles stop at this fraction of light radius (can be more than 1)"};
-cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "3", "maximum number of bounces for a particle (minimum is 1)"};
+cvar_t r_shadow_bouncegrid_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_lightradiusscale", "10", "particles stop at this fraction of light radius (can be more than 1)"};
+cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "5", "maximum number of bounces for a particle (minimum is 1)"};
cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "4", "amount of energy carried over after each bounce, this is a multiplier of texture color and the result is clamped to 1 or less, to prevent adding energy on each bounce"};
-cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "2", "brightness of particles contributing to bouncegrid texture"};
-cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "5000", "total photons to shoot per update, divided proportionately between lights"};
+cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "1", "brightness of particles contributing to bouncegrid texture"};
+cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "2000", "total photons to shoot per update, divided proportionately between lights"};
cvar_t r_shadow_bouncegrid_spacingx = {CVAR_SAVE, "r_shadow_bouncegrid_spacingx", "64", "unit size of bouncegrid pixel on X axis"};
cvar_t r_shadow_bouncegrid_spacingy = {CVAR_SAVE, "r_shadow_bouncegrid_spacingy", "64", "unit size of bouncegrid pixel on Y axis"};
cvar_t r_shadow_bouncegrid_spacingz = {CVAR_SAVE, "r_shadow_bouncegrid_spacingz", "64", "unit size of bouncegrid pixel on Z axis"};
+cvar_t r_shadow_bouncegrid_static = {CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
+cvar_t r_shadow_bouncegrid_static_photons = {CVAR_SAVE, "r_shadow_bouncegrid_static_photons", "25000", "photons value to use when in static mode"};
+cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
cvar_t r_shadow_bouncegrid_updateinterval = {CVAR_SAVE, "r_shadow_bouncegrid_updateinterval", "0", "update bouncegrid texture once per this many seconds, useful values are 0, 0.05, or 1000000"};
cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"};
cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
+typedef struct r_shadow_bouncegrid_settings_s
+{
+ qboolean staticmode;
+ qboolean bounceanglediffuse;
+ qboolean directionalshading;
+ float dlightparticlemultiplier;
+ qboolean hitmodels;
+ float lightradiusscale;
+ int maxbounce;
+ float particlebounceintensity;
+ float particleintensity;
+ int photons;
+ float spacing[3];
+ int stablerandom;
+}
+r_shadow_bouncegrid_settings_t;
+
+r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
rtexture_t *r_shadow_bouncegridtexture;
matrix4x4_t r_shadow_bouncegridmatrix;
vec_t r_shadow_bouncegridintensity;
+qboolean r_shadow_bouncegriddirectional;
static double r_shadow_bouncegridtime;
static int r_shadow_bouncegridresolution[3];
static int r_shadow_bouncegridnumpixels;
r_shadow_bouncegridhighpixels = NULL;
r_shadow_bouncegridnumpixels = 0;
r_shadow_bouncegridtexture = NULL;
+ r_shadow_bouncegriddirectional = false;
r_shadow_attenuationgradienttexture = NULL;
r_shadow_attenuation2dtexture = NULL;
r_shadow_attenuation3dtexture = NULL;
r_shadow_bouncegridpixels = NULL;
r_shadow_bouncegridhighpixels = NULL;
r_shadow_bouncegridnumpixels = 0;
+ r_shadow_bouncegriddirectional = false;
r_shadow_attenuationgradienttexture = NULL;
r_shadow_attenuation2dtexture = NULL;
r_shadow_attenuation3dtexture = NULL;
Cvar_RegisterVariable(&r_shadow_texture3d);
Cvar_RegisterVariable(&r_shadow_bouncegrid);
Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_directionalshading);
Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier);
Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels);
Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingx);
Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingy);
Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingz);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_static_photons);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
void R_Shadow_RenderMode_Reset(void)
{
- R_Mesh_ResetRenderTargets();
+ R_Mesh_SetMainRenderTargets();
R_SetViewport(&r_refdef.view.viewport);
GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
R_Mesh_ResetTextureState();
r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
R_Mesh_ResetTextureState();
- R_Mesh_ResetRenderTargets();
R_Shadow_RenderMode_Reset();
- if (fbo)
- {
- R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
- R_SetupShader_DepthOrShadow();
- }
- else
- R_SetupShader_ShowDepth();
+ R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
+ R_SetupShader_DepthOrShadow();
GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
GL_DepthMask(true);
GL_DepthTest(true);
void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
{
R_Mesh_ResetTextureState();
- R_Mesh_ResetRenderTargets();
+ R_Mesh_SetMainRenderTargets();
if (transparent)
{
r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
// only draw light where this geometry was already rendered AND the
// stencil is 128 (values other than this mean shadow)
R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
- R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+ if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
+ R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+ else
+ R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
r_shadow_usingshadowmap2d = shadowmapping;
vec_t photonresidual;
float m[16];
float texlerp[2][3];
- float splatcolor[3];
+ float splatcolor[16];
float pixelweight[8];
+ float w;
+ int c[4];
int pixelindex[8];
int corner;
- int x, y, z;
- qboolean isstatic = r_shadow_bouncegrid_updateinterval.value > 1.0f;
+ int x, y, z, d;
rtlight_t *rtlight;
- if (!r_shadow_bouncegrid.integer || !vid.support.ext_texture_3d)
+ r_shadow_bouncegrid_settings_t settings;
+ qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
+ qboolean allowdirectionalshading = false;
+ switch(vid.renderpath)
+ {
+ case RENDERPATH_GL20:
+ allowdirectionalshading = true;
+ if (!vid.support.ext_texture_3d)
+ return;
+ break;
+ case RENDERPATH_GLES2:
+ // for performance reasons, do not use directional shading on GLES devices
+ if (!vid.support.ext_texture_3d)
+ return;
+ break;
+ // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
+ case RENDERPATH_GL11:
+ case RENDERPATH_GL13:
+ case RENDERPATH_SOFT:
+ case RENDERPATH_D3D9:
+ case RENDERPATH_D3D10:
+ case RENDERPATH_D3D11:
+ return;
+ }
+
+ r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
+
+ // see if there are really any lights to render...
+ if (enable && r_shadow_bouncegrid_static.integer)
+ {
+ enable = false;
+ 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))
+ continue;
+ rtlight = &light->rtlight;
+ // when static, we skip styled lights because they tend to change...
+ if (rtlight->style > 0)
+ continue;
+ VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
+ if (!VectorLength2(lightcolor))
+ continue;
+ enable = true;
+ break;
+ }
+ }
+
+ if (!enable)
{
if (r_shadow_bouncegridtexture)
{
Mem_Free(r_shadow_bouncegridhighpixels);
r_shadow_bouncegridhighpixels = NULL;
r_shadow_bouncegridnumpixels = 0;
+ r_shadow_bouncegriddirectional = false;
return;
}
- if (r_refdef.scene.worldmodel && isstatic)
- {
- VectorSet(spacing, bound(1, r_shadow_bouncegrid_spacingx.value, 512), bound(1, r_shadow_bouncegrid_spacingy.value, 512), bound(1, r_shadow_bouncegrid_spacingz.value, 512));
- VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
- VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
- VectorSubtract(maxs, mins, size);
- resolution[0] = (int)floor(size[0] / spacing[0] + 0.5f);
- resolution[1] = (int)floor(size[1] / spacing[1] + 0.5f);
- resolution[2] = (int)floor(size[2] / spacing[2] + 0.5f);
- resolution[0] = min(resolution[0], bound(4, r_shadow_bouncegrid_x.integer, (int)vid.maxtexturesize_3d));
- resolution[1] = min(resolution[1], bound(4, r_shadow_bouncegrid_y.integer, (int)vid.maxtexturesize_3d));
- resolution[2] = min(resolution[2], bound(4, r_shadow_bouncegrid_z.integer, (int)vid.maxtexturesize_3d));
- spacing[0] = size[0] / resolution[0];
- spacing[1] = size[1] / resolution[1];
- spacing[2] = size[2] / resolution[2];
- ispacing[0] = 1.0f / spacing[0];
- ispacing[1] = 1.0f / spacing[1];
- ispacing[2] = 1.0f / spacing[2];
+
+ // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
+ memset(&settings, 0, sizeof(settings));
+ settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
+ settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
+ settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
+ settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
+ settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
+ settings.lightradiusscale = r_shadow_bouncegrid_lightradiusscale.value;
+ settings.maxbounce = r_shadow_bouncegrid_maxbounce.integer;
+ settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
+ settings.particleintensity = r_shadow_bouncegrid_particleintensity.value;
+ settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
+ settings.spacing[0] = r_shadow_bouncegrid_spacingx.value;
+ settings.spacing[1] = r_shadow_bouncegrid_spacingy.value;
+ settings.spacing[2] = r_shadow_bouncegrid_spacingz.value;
+ settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
+
+ // bound the values for sanity
+ settings.photons = bound(1, settings.photons, 1048576);
+ settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
+ settings.maxbounce = bound(1, settings.maxbounce, 16);
+ settings.spacing[0] = bound(1, settings.spacing[0], 512);
+ settings.spacing[1] = bound(1, settings.spacing[1], 512);
+ settings.spacing[2] = bound(1, settings.spacing[2], 512);
+
+ // get the spacing values
+ spacing[0] = settings.spacing[0];
+ spacing[1] = settings.spacing[1];
+ spacing[2] = settings.spacing[2];
+ ispacing[0] = 1.0f / spacing[0];
+ ispacing[1] = 1.0f / spacing[1];
+ ispacing[2] = 1.0f / spacing[2];
+
+ // calculate texture size enclosing entire world bounds at the spacing
+ VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
+ VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
+ VectorSubtract(maxs, mins, size);
+ // now we can calculate the resolution we want
+ c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
+ c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
+ c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
+ // figure out the exact texture size (honoring power of 2 if required)
+ c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
+ c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
+ c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
+ if (vid.support.arb_texture_non_power_of_two)
+ {
+ resolution[0] = c[0];
+ resolution[1] = c[1];
+ resolution[2] = c[2];
}
else
{
- VectorSet(resolution, bound(4, r_shadow_bouncegrid_x.integer, (int)vid.maxtexturesize_3d), bound(4, r_shadow_bouncegrid_y.integer, (int)vid.maxtexturesize_3d), bound(4, r_shadow_bouncegrid_z.integer, (int)vid.maxtexturesize_3d));
- VectorSet(spacing, bound(1, r_shadow_bouncegrid_spacingx.value, 512), bound(1, r_shadow_bouncegrid_spacingy.value, 512), bound(1, r_shadow_bouncegrid_spacingz.value, 512));
- VectorMultiply(resolution, spacing, size);
- ispacing[0] = 1.0f / spacing[0];
- ispacing[1] = 1.0f / spacing[1];
- ispacing[2] = 1.0f / spacing[2];
+ for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
+ for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
+ for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
+ }
+ size[0] = spacing[0] * resolution[0];
+ size[1] = spacing[1] * resolution[1];
+ size[2] = spacing[2] * resolution[2];
+
+ // if dynamic we may or may not want to use the world bounds
+ // if the dynamic size is smaller than the world bounds, use it instead
+ if (!settings.staticmode && (r_shadow_bouncegrid_x.integer * r_shadow_bouncegrid_y.integer * r_shadow_bouncegrid_z.integer < resolution[0] * resolution[1] * resolution[2]))
+ {
+ // we know the resolution we want
+ c[0] = r_shadow_bouncegrid_x.integer;
+ c[1] = r_shadow_bouncegrid_y.integer;
+ c[2] = r_shadow_bouncegrid_z.integer;
+ // now we can calculate the texture size (power of 2 if required)
+ c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
+ c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
+ c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
+ if (vid.support.arb_texture_non_power_of_two)
+ {
+ resolution[0] = c[0];
+ resolution[1] = c[1];
+ resolution[2] = c[2];
+ }
+ else
+ {
+ for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
+ for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
+ for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
+ }
+ size[0] = spacing[0] * resolution[0];
+ size[1] = spacing[1] * resolution[1];
+ size[2] = spacing[2] * resolution[2];
+ // center the rendering on the view
mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
- VectorAdd(mins, size, maxs);
}
- r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
- if (r_shadow_bouncegridtexture && realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value && resolution[0] == r_shadow_bouncegridresolution[0] && resolution[1] == r_shadow_bouncegridresolution[1] && resolution[2] == r_shadow_bouncegridresolution[2])
+
+ // recalculate the maxs in case the resolution was not satisfactory
+ VectorAdd(mins, size, maxs);
+
+ // if all the settings seem identical to the previous update, return
+ if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
return;
+
+ // store the new settings
+ r_shadow_bouncegridsettings = settings;
+
// we're going to update the bouncegrid, update the matrix...
memset(m, 0, sizeof(m));
m[0] = 1.0f / size[0];
m[10] = 1.0f / size[2];
m[11] = -mins[2] * m[10];
m[15] = 1.0f;
+ if (settings.directionalshading)
+ {
+ m[10] *= 0.25f;
+ m[11] *= 0.25f;
+ }
Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
numpixels = resolution[0]*resolution[1]*resolution[2];
+ if (settings.directionalshading)
+ numpixels *= 4;
+ r_shadow_bouncegriddirectional = settings.directionalshading;
// reallocate pixels for this update if needed...
if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
{
+ if (r_shadow_bouncegridtexture)
+ {
+ R_FreeTexture(r_shadow_bouncegridtexture);
+ r_shadow_bouncegridtexture = NULL;
+ }
r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
- r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[3]));
+ r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
}
r_shadow_bouncegridnumpixels = numpixels;
pixels = r_shadow_bouncegridpixels;
highpixels = r_shadow_bouncegridhighpixels;
- memset(pixels, 0, numpixels * sizeof(unsigned char[4]));
- memset(highpixels, 0, numpixels * sizeof(float[3]));
+ if (settings.directionalshading)
+ memset(pixels, 128, numpixels * sizeof(unsigned char[4]));
+ else
+ memset(pixels, 0, numpixels * sizeof(unsigned char[4]));
+ memset(highpixels, 0, numpixels * sizeof(float[4]));
// figure out what we want to interact with
- if (r_shadow_bouncegrid_hitmodels.integer)
+ if (settings.hitmodels)
hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_LIQUIDSMASK;
else
hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK;
- maxbounce = bound(1, r_shadow_bouncegrid_maxbounce.integer, 16);
+ maxbounce = settings.maxbounce;
+ // clear variables that produce warnings otherwise
+ memset(splatcolor, 0, sizeof(splatcolor));
// iterate world rtlights
range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
- range1 = isstatic ? 0 : r_refdef.scene.numlights;
+ range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
range2 = range + range1;
photoncount = 0;
for (lightindex = 0;lightindex < range2;lightindex++)
{
- if (isstatic)
+ if (settings.staticmode)
{
light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
if (!light || !(light->flags & flag))
// vary with lightstyle, otherwise we get randomized particle
// distribution, the seeded random is only consistent for a
// consistent number of particles on this light...
- radius = rtlight->radius * bound(0.0001f, r_shadow_bouncegrid_lightradiusscale.value, 1024.0f);
+ radius = rtlight->radius * settings.lightradiusscale;
s = rtlight->radius;
lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
if (lightindex >= range)
- lightintensity *= r_shadow_bouncegrid_dlightparticlemultiplier.value;
+ lightintensity *= settings.dlightparticlemultiplier;
photoncount += max(0.0f, lightintensity * s * s);
}
- photonscaling = bound(1, r_shadow_bouncegrid_photons.value, 1048576) / max(1, photoncount);
+ photonscaling = (float)settings.photons / max(1, photoncount);
photonresidual = 0.0f;
for (lightindex = 0;lightindex < range2;lightindex++)
{
- if (isstatic)
+ if (settings.staticmode)
{
light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
if (!light || !(light->flags & flag))
// vary with lightstyle, otherwise we get randomized particle
// distribution, the seeded random is only consistent for a
// consistent number of particles on this light...
- radius = rtlight->radius * bound(0.0001f, r_shadow_bouncegrid_lightradiusscale.value, 1024.0f);
+ radius = rtlight->radius * settings.lightradiusscale;
s = rtlight->radius;
lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
if (lightindex >= range)
- lightintensity *= r_shadow_bouncegrid_dlightparticlemultiplier.value;
+ lightintensity *= settings.dlightparticlemultiplier;
photonresidual += lightintensity * s * s * photonscaling;
shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
if (!shootparticles)
continue;
photonresidual -= shootparticles;
- s = r_shadow_bouncegrid_particleintensity.value / shootparticles;
+ s = settings.particleintensity / shootparticles;
VectorScale(lightcolor, s, baseshotcolor);
if (VectorLength2(baseshotcolor) == 0.0f)
break;
r_refdef.stats.bouncegrid_particles += shootparticles;
for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
{
- if (r_shadow_bouncegrid_stablerandom.integer > 0)
+ if (settings.stablerandom > 0)
seed = lightindex * 11937 + shotparticles;
VectorCopy(baseshotcolor, shotcolor);
VectorCopy(rtlight->shadoworigin, clipstart);
- if (r_shadow_bouncegrid_stablerandom.integer < 0)
+ if (settings.stablerandom < 0)
VectorRandom(clipend);
else
VectorCheeseRandom(clipend);
r_refdef.stats.bouncegrid_traces++;
//r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
//r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
- cliptrace = CL_TraceLine(clipstart, clipend, r_shadow_bouncegrid_hitmodels.integer ? MOVE_HITMODEL : MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true, true);
- //Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask);
+ if (settings.staticmode)
+ Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask, true);
+ else
+ cliptrace = CL_TraceLine(clipstart, clipend, settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true, true);
if (cliptrace.fraction >= 1.0f)
break;
r_refdef.stats.bouncegrid_hits++;
tex[2] = (int)floor(texlerp[1][2]);
if (tex[0] >= 1 && tex[1] >= 1 && tex[2] >= 1 && tex[0] < resolution[0] - 2 && tex[1] < resolution[1] - 2 && tex[2] < resolution[2] - 2)
{
- // it is within bounds...
- splatcolor[0] = shotcolor[2] * 255.0f;
- splatcolor[1] = shotcolor[1] * 255.0f;
- splatcolor[2] = shotcolor[0] * 255.0f;
+ // it is within bounds... do the real work now
+ // calculate first order spherical harmonics values (average, slopeX, slopeY, slopeZ)
+ if (settings.directionalshading)
+ {
+ VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
+ VectorNormalize(clipdiff);
+ splatcolor[ 0] = shotcolor[0] * clipdiff[2];
+ splatcolor[ 1] = shotcolor[0] * clipdiff[1];
+ splatcolor[ 2] = shotcolor[0] * clipdiff[0];
+ splatcolor[ 3] = shotcolor[0];
+ splatcolor[ 4] = shotcolor[1] * clipdiff[2];
+ splatcolor[ 5] = shotcolor[1] * clipdiff[1];
+ splatcolor[ 6] = shotcolor[1] * clipdiff[0];
+ splatcolor[ 7] = shotcolor[1];
+ splatcolor[ 8] = shotcolor[2] * clipdiff[2];
+ splatcolor[ 9] = shotcolor[2] * clipdiff[1];
+ splatcolor[10] = shotcolor[2] * clipdiff[0];
+ splatcolor[11] = shotcolor[2];
+ w = VectorLength(shotcolor);
+ splatcolor[12] = clipdiff[2] * w;
+ splatcolor[13] = clipdiff[1] * w;
+ splatcolor[14] = clipdiff[0] * w;
+ splatcolor[15] = 1.0f;
+ }
+ else
+ {
+ splatcolor[ 0] = shotcolor[2];
+ splatcolor[ 1] = shotcolor[1];
+ splatcolor[ 2] = shotcolor[0];
+ splatcolor[ 3] = 1.0f;
+ }
// calculate the lerp factors
texlerp[1][0] -= tex[0];
texlerp[1][1] -= tex[1];
// update the 8 pixels...
for (corner = 0;corner < 8;corner++)
{
+ // calculate address for first set of coefficients
+ w = pixelweight[corner];
pixel = pixels + 4 * pixelindex[corner];
- highpixel = highpixels + 3 * pixelindex[corner];
+ highpixel = highpixels + 4 * pixelindex[corner];
// add to the high precision pixel color
- highpixel[0] += (splatcolor[0]*pixelweight[corner]);
- highpixel[1] += (splatcolor[1]*pixelweight[corner]);
- highpixel[2] += (splatcolor[2]*pixelweight[corner]);
+ highpixel[0] += (splatcolor[ 0]*w);
+ highpixel[1] += (splatcolor[ 1]*w);
+ highpixel[2] += (splatcolor[ 2]*w);
+ highpixel[3] += (splatcolor[ 3]*w);
// flag the low precision pixel as needing to be updated
pixel[3] = 255;
+ if (settings.directionalshading)
+ {
+ // advance to second set of coefficients
+ pixel += numpixels;
+ highpixel += numpixels;
+ // add to the high precision pixel color
+ highpixel[0] += (splatcolor[ 4]*w);
+ highpixel[1] += (splatcolor[ 5]*w);
+ highpixel[2] += (splatcolor[ 6]*w);
+ highpixel[3] += (splatcolor[ 7]*w);
+ // flag the low precision pixel as needing to be updated
+ pixel[3] = 255;
+ // advance to third set of coefficients
+ pixel += numpixels;
+ highpixel += numpixels;
+ // add to the high precision pixel color
+ highpixel[0] += (splatcolor[ 8]*w);
+ highpixel[1] += (splatcolor[ 9]*w);
+ highpixel[2] += (splatcolor[10]*w);
+ highpixel[3] += (splatcolor[11]*w);
+ // flag the low precision pixel as needing to be updated
+ pixel[3] = 255;
+ // advance to fourth set of coefficients
+ pixel += numpixels;
+ highpixel += numpixels;
+ // add to the high precision pixel color
+ highpixel[0] += (splatcolor[12]*w);
+ highpixel[1] += (splatcolor[13]*w);
+ highpixel[2] += (splatcolor[14]*w);
+ highpixel[3] += (splatcolor[15]*w);
+ // flag the low precision pixel as needing to be updated
+ pixel[3] = 255;
+ }
}
}
}
VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
else
VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
- VectorScale(surfcolor, r_shadow_bouncegrid_particlebounceintensity.value, surfcolor);
+ VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
surfcolor[0] = min(surfcolor[0], 1.0f);
surfcolor[1] = min(surfcolor[1], 1.0f);
surfcolor[2] = min(surfcolor[2], 1.0f);
if (VectorLength2(baseshotcolor) == 0.0f)
break;
r_refdef.stats.bouncegrid_bounces++;
- if (r_shadow_bouncegrid_bounceanglediffuse.integer)
+ if (settings.bounceanglediffuse)
{
// random direction, primarily along plane normal
s = VectorDistance(cliptrace.endpos, clipend);
- if (r_shadow_bouncegrid_stablerandom.integer < 0)
+ if (settings.stablerandom < 0)
VectorRandom(clipend);
else
VectorCheeseRandom(clipend);
// generate pixels array from highpixels array
// skip first and last columns, rows, and layers as these are blank
// the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
- for (z = 1;z < resolution[2]-1;z++)
+ for (d = 0;d < 4;d++)
{
- for (y = 1;y < resolution[1]-1;y++)
+ for (z = 1;z < resolution[2]-1;z++)
{
- for (x = 1, pixelindex[0] = (resolution[1]*z+y)*resolution[0]+x, pixel = pixels + 4*pixelindex[0], highpixel = highpixels + 3*pixelindex[0];x < resolution[0]-1;x++, pixel += 4, highpixel += 3)
+ for (y = 1;y < resolution[1]-1;y++)
{
- // only convert pixels that were hit by photons
- if (pixel[3])
+ for (x = 1, pixelindex[0] = ((d*resolution[2]+z)*resolution[1]+y)*resolution[0]+x, pixel = pixels + 4*pixelindex[0], highpixel = highpixels + 4*pixelindex[0];x < resolution[0]-1;x++, pixel += 4, highpixel += 4)
{
- pixel[0] = (unsigned char)min(highpixel[0], 255);
- pixel[1] = (unsigned char)min(highpixel[1], 255);
- pixel[2] = (unsigned char)min(highpixel[2], 255);
+ // only convert pixels that were hit by photons
+ if (pixel[3] == 255)
+ {
+ // normalize the bentnormal...
+ if (settings.directionalshading)
+ {
+ if (d == 3)
+ VectorNormalize(highpixel);
+ c[0] = (int)(highpixel[0]*128.0f+128.0f);
+ c[1] = (int)(highpixel[1]*128.0f+128.0f);
+ c[2] = (int)(highpixel[2]*128.0f+128.0f);
+ c[3] = (int)(highpixel[3]*128.0f+128.0f);
+ }
+ else
+ {
+ c[0] = (int)(highpixel[0]*256.0f);
+ c[1] = (int)(highpixel[1]*256.0f);
+ c[2] = (int)(highpixel[2]*256.0f);
+ c[3] = (int)(highpixel[3]*256.0f);
+ }
+ pixel[0] = (unsigned char)bound(0, c[0], 255);
+ pixel[1] = (unsigned char)bound(0, c[1], 255);
+ pixel[2] = (unsigned char)bound(0, c[2], 255);
+ pixel[3] = (unsigned char)bound(0, c[3], 255);
+ }
}
}
}
+ if (!settings.directionalshading)
+ break;
}
if (r_shadow_bouncegridtexture && r_shadow_bouncegridresolution[0] == resolution[0] && r_shadow_bouncegridresolution[1] == resolution[1] && r_shadow_bouncegridresolution[2] == resolution[2])
- R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]);
+ R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*(settings.directionalshading ? 4 : 1));
else
{
VectorCopy(resolution, r_shadow_bouncegridresolution);
if (r_shadow_bouncegridtexture)
R_FreeTexture(r_shadow_bouncegridtexture);
- r_shadow_bouncegridtexture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2], pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
+ r_shadow_bouncegridtexture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*(settings.directionalshading ? 4 : 1), pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
}
r_shadow_bouncegridtime = realtime;
}
qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
{
- if (!r_shadow_scissor.integer)
+ if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass)
{
r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
if (r_refdef.scene.lights[lnum]->draw)
R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
- R_Mesh_ResetRenderTargets();
+ R_Mesh_SetMainRenderTargets();
R_Shadow_RenderMode_End();
#if 0
// debugging
- R_Mesh_ResetRenderTargets();
+ R_Mesh_SetMainRenderTargets();
R_SetupShader_ShowDepth();
GL_ColorMask(1,1,1,1);
GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
origin[1] = atof(Cmd_Argv(3));
origin[2] = atof(Cmd_Argv(4));
}
+ else if (!strcmp(Cmd_Argv(1), "originscale"))
+ {
+ if (Cmd_Argc() != 5)
+ {
+ Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
+ return;
+ }
+ origin[0] *= atof(Cmd_Argv(2));
+ origin[1] *= atof(Cmd_Argv(3));
+ origin[2] *= atof(Cmd_Argv(4));
+ }
else if (!strcmp(Cmd_Argv(1), "originx"))
{
if (Cmd_Argc() != 3)
"colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
"radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
"sizescale scale : multiply radius (size) of light (1 does nothing)\n"
+"originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
"style style : set lightstyle of light (flickering patterns, switches, etc)\n"
"cubemap basename : set filter cubemap of light (not yet supported)\n"
"shadows 1/0 : turn on/off shadows\n"
=============================================================================
*/
+void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
+{
+ int i, numlights, flag;
+ float f, relativepoint[3], dist, dist2, lightradius2;
+ vec3_t diffuse, n;
+ rtlight_t *light;
+ dlight_t *dlight;
+
+ VectorClear(color);
+
+ if (r_fullbright.integer)
+ {
+ VectorSet(color, 1, 1, 1);
+ return;
+ }
+
+ if (flags & LP_LIGHTMAP)
+ {
+ if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
+ {
+ r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
+ color[0] += r_refdef.scene.ambient + diffuse[0];
+ color[1] += r_refdef.scene.ambient + diffuse[1];
+ color[2] += r_refdef.scene.ambient + diffuse[2];
+ }
+ else
+ VectorSet(color, 1, 1, 1);
+ }
+ if (flags & LP_RTWORLD)
+ {
+ flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
+ numlights = 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;
+ f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
+ if (f <= 0)
+ continue;
+ // todo: add to both ambient and diffuse
+ if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
+ VectorMA(color, f, light->currentcolor, color);
+ }
+ }
+ 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;
+ f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
+ if (f <= 0)
+ continue;
+ // todo: add to both ambient and diffuse
+ if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
+ VectorMA(color, f, light->color, color);
+ }
+ }
+}
+
void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
{
int i, numlights, flag;
return;
}
- if (flags & LP_LIGHTMAP)
+ if (flags == LP_LIGHTMAP)
{
VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
VectorClear(diffuse);
projects / xonotic / darkplaces.git / blobdiff