rtexture_t *r_shadow_shadowmap2ddepthtexture;
rtexture_t *r_shadow_shadowmapvsdcttexture;
int r_shadow_shadowmapsize; // changes for each light based on distance
-int r_shadow_shadowmaplod; // changes for each light based on distance
GLuint r_shadow_prepassgeometryfbo;
GLuint r_shadow_prepasslightingdiffusespecularfbo;
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, only active on levels with realtime lights active (r_shadow_realtime_world is usually required for these)"};
+cvar_t r_shadow_bouncegrid_blur = {CVAR_SAVE, "r_shadow_bouncegrid_blur", "1", "apply a 1-radius blur on bouncegrid to denoise it and deal with boundary issues with surfaces"};
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 8x 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_dynamic_culllightpaths = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_culllightpaths", "1", "skip accumulating light in the bouncegrid texture where the light paths are out of view (dynamic mode only)"};
+cvar_t r_shadow_bouncegrid_dynamic_dlightparticlemultiplier = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_dlightparticlemultiplier", "1", "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_dynamic_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_directionalshading", "0", "use diffuse shading rather than ambient, 3D texture becomes 8x as many pixels to hold the additional data"};
+cvar_t r_shadow_bouncegrid_dynamic_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
+cvar_t r_shadow_bouncegrid_dynamic_energyperphoton = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_energyperphoton", "10000", "amount of light that one photon should represent"};
+cvar_t r_shadow_bouncegrid_dynamic_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_lightradiusscale", "10", "particles stop at this fraction of light radius (can be more than 1)"};
+cvar_t r_shadow_bouncegrid_dynamic_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_maxbounce", "5", "maximum number of bounces for a particle (minimum is 0)"};
+cvar_t r_shadow_bouncegrid_dynamic_maxphotons = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_maxphotons", "25000", "upper bound on photons to shoot per update, divided proportionately between lights - normally the number of photons is calculated by energyperphoton"};
+cvar_t r_shadow_bouncegrid_dynamic_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_spacing", "64", "unit size of bouncegrid pixel"};
+cvar_t r_shadow_bouncegrid_dynamic_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_stablerandom", "1", "make particle distribution consistent from frame to frame"};
+cvar_t r_shadow_bouncegrid_dynamic_updateinterval = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_updateinterval", "0", "update bouncegrid texture once per this many seconds, useful values are 0, 0.05, or 1000000"};
+cvar_t r_shadow_bouncegrid_dynamic_x = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_x", "64", "maximum texture size of bouncegrid on X axis"};
+cvar_t r_shadow_bouncegrid_dynamic_y = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_y", "64", "maximum texture size of bouncegrid on Y axis"};
+cvar_t r_shadow_bouncegrid_dynamic_z = {CVAR_SAVE, "r_shadow_bouncegrid_dynamic_z", "32", "maximum texture size of bouncegrid on Z axis"};
+cvar_t r_shadow_bouncegrid_floatcolors = {CVAR_SAVE, "r_shadow_bouncegrid_floatcolors", "1", "upload texture as RGBA16F (or RGBA32F when set to 2) rather than RGBA8 format - this gives more dynamic range and accuracy"};
cvar_t r_shadow_bouncegrid_includedirectlighting = {CVAR_SAVE, "r_shadow_bouncegrid_includedirectlighting", "0", "allows direct lighting to be recorded, not just indirect (gives an effect somewhat like r_shadow_realtime_world_lightmaps)"};
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", "4", "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", "2", "maximum number of bounces for a particle (minimum is 0)"};
-cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "1", "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", "1", "brightness of particles contributing to bouncegrid texture"};
-cvar_t r_shadow_bouncegrid_maxphotons = {CVAR_SAVE, "r_shadow_bouncegrid_maxphotons", "25000", "upper bound on photons to shoot per update, divided proportionately between lights - normally the number of photons is calculated by intensityperphoton"};
-cvar_t r_shadow_bouncegrid_intensityperphoton = {CVAR_SAVE, "r_shadow_bouncegrid_intensityperphoton", "10000", "amount of light that one photon should represent"};
-cvar_t r_shadow_bouncegrid_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_spacing", "64", "unit size of bouncegrid pixel"};
-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_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "2", "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", "0.25", "brightness of particles contributing to bouncegrid texture"};
+cvar_t r_shadow_bouncegrid_sortlightpaths = {CVAR_SAVE, "r_shadow_bouncegrid_sortlightpaths", "1", "sort light paths before accumulating them into the bouncegrid texture, this reduces cpu cache misses"};
+cvar_t r_shadow_bouncegrid_lightpathsize = {CVAR_SAVE, "r_shadow_bouncegrid_lightpathsize", "1", "width of the light path for accumulation of light in the bouncegrid texture"};
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_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
+cvar_t r_shadow_bouncegrid_static_energyperphoton = {CVAR_SAVE, "r_shadow_bouncegrid_static_energyperphoton", "10000", "amount of light that one photon should represent in static mode"};
cvar_t r_shadow_bouncegrid_static_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_static_lightradiusscale", "10", "particles stop at this fraction of light radius (can be more than 1) when in static mode"};
cvar_t r_shadow_bouncegrid_static_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_static_maxbounce", "5", "maximum number of bounces for a particle (minimum is 0) in static mode"};
cvar_t r_shadow_bouncegrid_static_maxphotons = {CVAR_SAVE, "r_shadow_bouncegrid_static_maxphotons", "250000", "upper bound on photons in static mode"};
-cvar_t r_shadow_bouncegrid_static_intensityperphoton = {CVAR_SAVE, "r_shadow_bouncegrid_static_intensityperphoton", "1000", "amount of light that one photon should represent in static mode"};
-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_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"};
-cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"};
-cvar_t r_shadow_bouncegrid_culllightpaths = {CVAR_SAVE, "r_shadow_bouncegrid_culllightpaths", "1", "skip accumulating light in the bouncegrid texture where the light paths are out of view (dynamic mode only)"};
-cvar_t r_shadow_bouncegrid_sortlightpaths = {CVAR_SAVE, "r_shadow_bouncegrid_sortlightpaths", "1", "sort light paths before accumulating them into the bouncegrid texture, this reduces cpu cache misses"};
+cvar_t r_shadow_bouncegrid_static_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_static_spacing", "64", "unit size of bouncegrid pixel when in static mode"};
cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "0", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksum the proportion of hidden pixels controls corona intensity"};
cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "0", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility) - bad performance (synchronous rendering) - worse on multi-gpu!"};
r_shadow_shadowmapshadowsampler = r_shadow_shadowmapping_useshadowsampler.integer != 0;
r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
- r_shadow_shadowmaplod = -1;
r_shadow_shadowmapsize = 0;
r_shadow_shadowmapsampler = false;
r_shadow_shadowmappcf = 0;
r_shadow_shadowmapvsdcttexture = NULL;
r_shadow_shadowmapmaxsize = 0;
r_shadow_shadowmapsize = 0;
- r_shadow_shadowmaplod = 0;
r_shadow_shadowmapfilterquality = -1;
r_shadow_shadowmapdepthbits = 0;
r_shadow_shadowmapvsdct = false;
Cvar_RegisterVariable(&r_shadow_polygonoffset);
Cvar_RegisterVariable(&r_shadow_texture3d);
Cvar_RegisterVariable(&r_shadow_bouncegrid);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_blur);
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_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_energyperphoton);
+ 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_spacing);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_stablerandom);
+ 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_lightradiusscale);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_lightpathsize);
Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_maxphotons);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_intensityperphoton);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_spacing);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_sortlightpaths);
Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_static_spacing);
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_intensityperphoton);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_y);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_z);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_culllightpaths);
- Cvar_RegisterVariable(&r_shadow_bouncegrid_sortlightpaths);
+ Cvar_RegisterVariable(&r_shadow_bouncegrid_static_energyperphoton);
Cvar_RegisterVariable(&r_coronas);
Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
Cvar_RegisterVariable(&r_coronas_occlusionquery);
R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
}
+#define MAXBOUNCEGRIDSPLATSIZE 7
+#define MAXBOUNCEGRIDSPLATSIZE1 (MAXBOUNCEGRIDSPLATSIZE+1)
+
// these are temporary data per-frame, sorted and performed in a more
// cache-friendly order than the original photons
typedef struct r_shadow_bouncegrid_splatpath_s
}
r_shadow_bouncegrid_splatpath_t;
-static void R_shadow_BounceGrid_AddSplatPath(vec3_t originalstart, vec3_t originalend, vec3_t color)
+static void R_Shadow_BounceGrid_AddSplatPath(vec3_t originalstart, vec3_t originalend, vec3_t color)
{
int bestaxis;
int numsplats;
// cull paths that fail R_CullBox in dynamic mode
if (!r_shadow_bouncegrid_state.settings.staticmode
- && r_shadow_bouncegrid_culllightpaths.integer)
+ && r_shadow_bouncegrid_dynamic_culllightpaths.integer)
{
vec3_t cullmins, cullmaxs;
cullmins[0] = min(originalstart[0], originalend[0]) - r_shadow_bouncegrid_state.settings.spacing[0];
static void R_Shadow_BounceGrid_GenerateSettings(r_shadow_bouncegrid_settings_t *settings)
{
+ qboolean s = r_shadow_bouncegrid_static.integer != 0;
+ float spacing = s ? r_shadow_bouncegrid_static_spacing.value : r_shadow_bouncegrid_dynamic_spacing.value;
+
// prevent any garbage in alignment padded areas as we'll be using memcmp
memset(settings, 0, sizeof(*settings));
// build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
- settings->staticmode = r_shadow_bouncegrid_static.integer != 0;
+ settings->staticmode = s;
+ settings->blur = r_shadow_bouncegrid_blur.integer != 0;
+ settings->floatcolors = bound(0, r_shadow_bouncegrid_floatcolors.integer, 2);
+ settings->lightpathsize = bound(1, r_shadow_bouncegrid_lightpathsize.integer, MAXBOUNCEGRIDSPLATSIZE);
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) && r_shadow_bouncegrid_state.allowdirectionalshading;
- settings->dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
- settings->hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
+ settings->directionalshading = (s ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_dynamic_directionalshading.integer != 0) && r_shadow_bouncegrid_state.allowdirectionalshading;
+ settings->dlightparticlemultiplier = s ? 0 : r_shadow_bouncegrid_dynamic_dlightparticlemultiplier.value;
+ settings->hitmodels = s ? false : r_shadow_bouncegrid_dynamic_hitmodels.integer != 0;
settings->includedirectlighting = r_shadow_bouncegrid_includedirectlighting.integer != 0 || r_shadow_bouncegrid.integer == 2;
- settings->lightradiusscale = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_lightradiusscale.value);
- settings->maxbounce = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_maxbounce.integer);
+ settings->lightradiusscale = (s ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_dynamic_lightradiusscale.value);
+ settings->maxbounce = (s ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_dynamic_maxbounce.integer);
settings->particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
- settings->particleintensity = r_shadow_bouncegrid_particleintensity.value * 16384.0f * (settings->directionalshading ? 4.0f : 1.0f) / (r_shadow_bouncegrid_spacing.value * r_shadow_bouncegrid_spacing.value);
- settings->maxphotons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_maxphotons.integer : r_shadow_bouncegrid_maxphotons.integer;
- settings->intensityperphoton = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_intensityperphoton.integer : r_shadow_bouncegrid_intensityperphoton.integer;
- settings->spacing[0] = r_shadow_bouncegrid_spacing.value;
- settings->spacing[1] = r_shadow_bouncegrid_spacing.value;
- settings->spacing[2] = r_shadow_bouncegrid_spacing.value;
- settings->stablerandom = r_shadow_bouncegrid_stablerandom.integer;
+ settings->particleintensity = r_shadow_bouncegrid_particleintensity.value * 16384.0f * (settings->directionalshading ? 4.0f : 1.0f) / (spacing * spacing);
+ settings->maxphotons = s ? r_shadow_bouncegrid_static_maxphotons.integer : r_shadow_bouncegrid_dynamic_maxphotons.integer;
+ settings->energyperphoton = s ? r_shadow_bouncegrid_static_energyperphoton.integer : r_shadow_bouncegrid_dynamic_energyperphoton.integer;
+ settings->spacing[0] = spacing;
+ settings->spacing[1] = spacing;
+ settings->spacing[2] = spacing;
+ settings->stablerandom = s ? 1 : r_shadow_bouncegrid_dynamic_stablerandom.integer;
// bound the values for sanity
settings->maxphotons = bound(1, settings->maxphotons, 25000000);
// 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]))
+ if (!settings->staticmode && (r_shadow_bouncegrid_dynamic_x.integer * r_shadow_bouncegrid_dynamic_y.integer * r_shadow_bouncegrid_dynamic_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;
+ c[0] = r_shadow_bouncegrid_dynamic_x.integer;
+ c[1] = r_shadow_bouncegrid_dynamic_y.integer;
+ c[2] = r_shadow_bouncegrid_dynamic_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);
r_shadow_bouncegrid_state.pixelsperband = resolution[0]*resolution[1]*resolution[2];
r_shadow_bouncegrid_state.bytesperband = r_shadow_bouncegrid_state.pixelsperband*4;
numpixels = r_shadow_bouncegrid_state.pixelsperband*r_shadow_bouncegrid_state.pixelbands;
- if (r_shadow_bouncegrid_state.numpixels != numpixels || !r_shadow_bouncegrid_state.pixels || !r_shadow_bouncegrid_state.highpixels)
+ if (r_shadow_bouncegrid_state.numpixels != numpixels)
{
if (r_shadow_bouncegrid_state.texture)
{
R_FreeTexture(r_shadow_bouncegrid_state.texture);
r_shadow_bouncegrid_state.texture = NULL;
}
- r_shadow_bouncegrid_state.pixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegrid_state.pixels, numpixels * sizeof(unsigned char[4]));
- r_shadow_bouncegrid_state.highpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegrid_state.highpixels, numpixels * sizeof(float[4]));
r_shadow_bouncegrid_state.numpixels = numpixels;
}
//if (VectorLength2(rtlight->photoncolor) == 0.0f)
// rtlight->photons = 0;
}
- // the user provided an intensityperphoton value which we try to use
+ // the user provided an energyperphoton value which we try to use
// if that results in too many photons to shoot this frame, then we cap it
// which causes photons to appear/disappear from frame to frame, so we don't
// like doing that in the typical case
- normalphotonscaling = 1.0f / max(0.0001f, r_shadow_bouncegrid_intensityperphoton.value);
+ normalphotonscaling = 1.0f / max(0.0001f, settings->energyperphoton);
maxphotonscaling = (float)settings->maxphotons / max(1, photoncount);
*photonscaling = min(normalphotonscaling, maxphotonscaling);
}
-static void R_Shadow_BounceGrid_ClearPixels(void)
-{
- int pixelband;
- for (pixelband = 0;pixelband < r_shadow_bouncegrid_state.pixelbands;pixelband++)
- {
- if (pixelband == 1)
- memset(r_shadow_bouncegrid_state.pixels + pixelband * r_shadow_bouncegrid_state.bytesperband, 128, r_shadow_bouncegrid_state.bytesperband);
- else
- memset(r_shadow_bouncegrid_state.pixels + pixelband * r_shadow_bouncegrid_state.bytesperband, 0, r_shadow_bouncegrid_state.bytesperband);
- }
- memset(r_shadow_bouncegrid_state.highpixels, 0, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
-}
-
static int R_Shadow_BounceGrid_SplatPathCompare(const void *pa, const void *pb)
{
r_shadow_bouncegrid_splatpath_t *a = (r_shadow_bouncegrid_splatpath_t *)pa;
return 0;
}
+static void R_Shadow_BounceGrid_ClearPixels(void)
+{
+ // clear the highpixels array we'll be accumulating into
+ r_shadow_bouncegrid_state.highpixels = (float *)R_FrameData_Alloc(r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
+ memset(r_shadow_bouncegrid_state.highpixels, 0, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
+}
+
static void R_Shadow_BounceGrid_PerformSplats(void)
{
+ int splatsize = r_shadow_bouncegrid_state.settings.lightpathsize;
+ int splatsize1 = splatsize + 1;
r_shadow_bouncegrid_splatpath_t *splatpaths = r_shadow_bouncegrid_state.splatpaths;
r_shadow_bouncegrid_splatpath_t *splatpath;
- unsigned char *pixel;
- unsigned char *pixels = r_shadow_bouncegrid_state.pixels;
- float *highpixel;
float *highpixels = r_shadow_bouncegrid_state.highpixels;
int numsplatpaths = r_shadow_bouncegrid_state.numsplatpaths;
int splatindex;
vec3_t steppos;
vec3_t stepdelta;
vec3_t dir;
- float texlerp[2][3];
+ float texcorner[3];
+ float texlerp[MAXBOUNCEGRIDSPLATSIZE1][3];
float splatcolor[32];
- float pixelweight[8];
- float w;
+ float boxweight = 1.0f / (splatsize * splatsize * splatsize);
int resolution[3];
int tex[3];
- int pixelindex[8];
- int corner;
int pixelsperband = r_shadow_bouncegrid_state.pixelsperband;
- int pixelband;
int pixelbands = r_shadow_bouncegrid_state.pixelbands;
int numsteps;
int step;
-
+
// hush warnings about uninitialized data - pixelbands doesn't change but...
memset(splatcolor, 0, sizeof(splatcolor));
// sort the splats before we execute them, to reduce cache misses
if (r_shadow_bouncegrid_sortlightpaths.integer)
qsort(splatpaths, numsplatpaths, sizeof(*splatpaths), R_Shadow_BounceGrid_SplatPathCompare);
-
+
+ // the middle row/column/layer of each splat are full intensity
+ for (step = 1;step < splatsize;step++)
+ VectorSet(texlerp[step], 1.0f, 1.0f, 1.0f);
+
splatpath = splatpaths;
for (splatindex = 0;splatindex < numsplatpaths;splatindex++, splatpath++)
{
-
// calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
// accumulate average shotcolor
VectorCopy(splatpath->splatdir, dir);
for (step = 0;step < numsteps;step++)
{
r_refdef.stats[r_stat_bouncegrid_splats]++;
- // figure out which texture pixels this is in
- texlerp[1][0] = steppos[0] - 0.5f;
- texlerp[1][1] = steppos[1] - 0.5f;
- texlerp[1][2] = steppos[2] - 0.5f;
- tex[0] = (int)floor(texlerp[1][0]);
- tex[1] = (int)floor(texlerp[1][1]);
- tex[2] = (int)floor(texlerp[1][2]);
+ // figure out the min corner of the pixels we'll need to update
+ texcorner[0] = steppos[0] - (splatsize1 * 0.5f);
+ texcorner[1] = steppos[1] - (splatsize1 * 0.5f);
+ texcorner[2] = steppos[2] - (splatsize1 * 0.5f);
+ tex[0] = (int)floor(texcorner[0]);
+ tex[1] = (int)floor(texcorner[1]);
+ tex[2] = (int)floor(texcorner[2]);
+ // only update if it is within reasonable bounds
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)
+ && tex[0] < resolution[0] - splatsize1
+ && tex[1] < resolution[1] - splatsize1
+ && tex[2] < resolution[2] - splatsize1)
{
// it is within bounds... do the real work now
- // calculate the lerp factors
- texlerp[1][0] -= tex[0];
- texlerp[1][1] -= tex[1];
- texlerp[1][2] -= tex[2];
- texlerp[0][0] = 1.0f - texlerp[1][0];
- texlerp[0][1] = 1.0f - texlerp[1][1];
- texlerp[0][2] = 1.0f - texlerp[1][2];
- // calculate individual pixel indexes and weights
- pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
- pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
- pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
- pixelindex[3] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0]+1);pixelweight[3] = (texlerp[1][0]*texlerp[1][1]*texlerp[0][2]);
- pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
- pixelindex[5] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[5] = (texlerp[1][0]*texlerp[0][1]*texlerp[1][2]);
- pixelindex[6] = (((tex[2]+1)*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[6] = (texlerp[0][0]*texlerp[1][1]*texlerp[1][2]);
- pixelindex[7] = (((tex[2]+1)*resolution[1]+tex[1]+1)*resolution[0]+tex[0]+1);pixelweight[7] = (texlerp[1][0]*texlerp[1][1]*texlerp[1][2]);
- // update the 8 pixels...
- for (pixelband = 0;pixelband < pixelbands;pixelband++)
+ int xi, yi, zi;
+
+ // calculate the antialiased box edges
+ texlerp[splatsize][0] = texcorner[0] - tex[0];
+ texlerp[splatsize][1] = texcorner[1] - tex[1];
+ texlerp[splatsize][2] = texcorner[2] - tex[2];
+ texlerp[0][0] = 1.0f - texlerp[splatsize][0];
+ texlerp[0][1] = 1.0f - texlerp[splatsize][1];
+ texlerp[0][2] = 1.0f - texlerp[splatsize][2];
+
+ // accumulate light onto the pixels
+ for (zi = 0;zi < splatsize1;zi++)
{
- for (corner = 0;corner < 8;corner++)
+ for (yi = 0;yi < splatsize1;yi++)
{
- // calculate address for pixel
- w = pixelweight[corner];
- pixel = pixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
- highpixel = highpixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
- // add to the high precision pixel color
- highpixel[0] += (splatcolor[pixelband*4+0]*w);
- highpixel[1] += (splatcolor[pixelband*4+1]*w);
- highpixel[2] += (splatcolor[pixelband*4+2]*w);
- highpixel[3] += (splatcolor[pixelband*4+3]*w);
- // flag the low precision pixel as needing to be updated
- pixel[3] = 255;
- // advance to next band of coefficients
- //pixel += pixelsperband*4;
- //highpixel += pixelsperband*4;
+ int index = ((tex[2]+zi)*resolution[1]+tex[1]+yi)*resolution[0]+tex[0];
+ for (xi = 0;xi < splatsize1;xi++, index++)
+ {
+ float w = texlerp[xi][0]*texlerp[yi][1]*texlerp[zi][2] * boxweight;
+ int band = 0;
+ float *p = highpixels + 4 * index + band * pixelsperband * 4;
+ for (;band < pixelbands;band++, p += pixelsperband * 4)
+ {
+ // add to the pixel color
+ p[0] += splatcolor[band*4+0] * w;
+ p[1] += splatcolor[band*4+1] * w;
+ p[2] += splatcolor[band*4+2] * w;
+ p[3] += splatcolor[band*4+3] * w;
+ }
+ }
}
}
}
}
}
+static void R_Shadow_BounceGrid_BlurPixelsInDirection(const float *inpixels, float *outpixels, int off)
+{
+ const float *inpixel;
+ float *outpixel;
+ int pixelbands = r_shadow_bouncegrid_state.pixelbands;
+ int pixelband;
+ unsigned int index;
+ unsigned int x, y, z;
+ unsigned int resolution[3];
+ VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
+ for (pixelband = 0;pixelband < pixelbands;pixelband++)
+ {
+ for (z = 1;z < resolution[2]-1;z++)
+ {
+ for (y = 1;y < resolution[1]-1;y++)
+ {
+ x = 1;
+ index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
+ inpixel = inpixels + 4*index;
+ outpixel = outpixels + 4*index;
+ for (;x < resolution[0]-1;x++, inpixel += 4, outpixel += 4)
+ {
+ outpixel[0] = (inpixel[0] + inpixel[ off] + inpixel[0-off]) * (1.0f / 3.0);
+ outpixel[1] = (inpixel[1] + inpixel[1+off] + inpixel[1-off]) * (1.0f / 3.0);
+ outpixel[2] = (inpixel[2] + inpixel[2+off] + inpixel[2-off]) * (1.0f / 3.0);
+ outpixel[3] = (inpixel[3] + inpixel[3+off] + inpixel[3-off]) * (1.0f / 3.0);
+ }
+ }
+ }
+ }
+}
+
+static void R_Shadow_BounceGrid_BlurPixels(void)
+{
+ float *highpixels = r_shadow_bouncegrid_state.highpixels;
+ float *temppixels1 = (float *)R_FrameData_Alloc(r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
+ float *temppixels2 = (float *)R_FrameData_Alloc(r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
+ unsigned int resolution[3];
+
+ if (!r_shadow_bouncegrid_blur.integer)
+ return;
+
+ VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
+
+ // blur on X
+ R_Shadow_BounceGrid_BlurPixelsInDirection(highpixels, temppixels1, 4);
+ // blur on Y
+ R_Shadow_BounceGrid_BlurPixelsInDirection(temppixels1, temppixels2, resolution[0] * 4);
+ // blur on Z
+ R_Shadow_BounceGrid_BlurPixelsInDirection(temppixels2, highpixels, resolution[0] * resolution[1] * 4);
+}
+
static void R_Shadow_BounceGrid_ConvertPixelsAndUpload(void)
{
- unsigned char *pixels = r_shadow_bouncegrid_state.pixels;
- unsigned char *pixel;
+ int floatcolors = r_shadow_bouncegrid_state.settings.floatcolors;
+ unsigned char *pixelsbgra8 = NULL;
+ unsigned char *pixelbgra8;
+ unsigned short *pixelsrgba16f = NULL;
+ unsigned short *pixelrgba16f;
+ float *pixelsrgba32f = NULL;
float *highpixels = r_shadow_bouncegrid_state.highpixels;
float *highpixel;
+ float *bandpixel;
+ unsigned int pixelsperband = r_shadow_bouncegrid_state.pixelsperband;
unsigned int pixelbands = r_shadow_bouncegrid_state.pixelbands;
unsigned int pixelband;
unsigned int x, y, z;
- unsigned int index;
+ unsigned int index, bandindex;
unsigned int resolution[3];
int c[4];
VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
- // generate pixels array from highpixels array
- //
- // skip first and last columns, rows, and layers as these are blank
+
+ if (r_shadow_bouncegrid_state.createtexture && r_shadow_bouncegrid_state.texture)
+ {
+ R_FreeTexture(r_shadow_bouncegrid_state.texture);
+ r_shadow_bouncegrid_state.texture = NULL;
+ }
+
+ // if bentnormals exist, we need to normalize and bias them for the shader
+ if (pixelbands > 1)
+ {
+ pixelband = 1;
+ for (z = 0;z < resolution[2]-1;z++)
+ {
+ for (y = 0;y < resolution[1]-1;y++)
+ {
+ x = 1;
+ index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
+ highpixel = highpixels + 4*index;
+ for (;x < resolution[0]-1;x++, index++, highpixel += 4)
+ {
+ // only convert pixels that were hit by photons
+ if (highpixel[3] != 0.0f)
+ VectorNormalize(highpixel);
+ VectorSet(highpixel, highpixel[0] * 0.5f + 0.5f, highpixel[1] * 0.5f + 0.5f, highpixel[2] * 0.5f + 0.5f);
+ highpixel[pixelsperband * 4 + 3] = 1.0f;
+ }
+ }
+ }
+ }
+
+ // start by clearing the pixels array - we won't be writing to all of it
//
- // the pixel[3] value was deliberately written along with highpixels
- // updates, so we can use it to detect only pixels that need to be
- // converted, the rest were already memset to neutral values.
- for (pixelband = 0;pixelband < pixelbands;pixelband++)
+ // then process only the pixels that have at least some color, skipping
+ // the higher bands for speed on pixels that are black
+ switch (floatcolors)
{
+ case 0:
+ pixelsbgra8 = (unsigned char *)R_FrameData_Alloc(r_shadow_bouncegrid_state.numpixels * sizeof(unsigned char[4]));
+ for (pixelband = 0;pixelband < pixelbands;pixelband++)
+ {
+ if (pixelband == 1)
+ memset(pixelsbgra8 + pixelband * r_shadow_bouncegrid_state.bytesperband, 128, r_shadow_bouncegrid_state.bytesperband);
+ else
+ memset(pixelsbgra8 + pixelband * r_shadow_bouncegrid_state.bytesperband, 0, r_shadow_bouncegrid_state.bytesperband);
+ }
for (z = 1;z < resolution[2]-1;z++)
{
for (y = 1;y < resolution[1]-1;y++)
{
x = 1;
+ pixelband = 0;
index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
- pixel = pixels + 4*index;
highpixel = highpixels + 4*index;
- for (;x < resolution[0]-1;x++, pixel += 4, highpixel += 4)
+ for (;x < resolution[0]-1;x++, index++, highpixel += 4)
{
// only convert pixels that were hit by photons
- if (pixel[3] == 255)
+ if (VectorLength2(highpixel))
{
- // normalize the bentnormal...
- if (pixelband == 1)
+ // normalize the bentnormal now
+ if (pixelbands > 1)
{
- 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);
+ VectorNormalize(highpixel + pixelsperband * 4);
+ highpixel[pixelsperband * 4 + 3] = 1.0f;
}
- else
+ // process all of the pixelbands for this pixel
+ for (pixelband = 0, bandindex = index;pixelband < pixelbands;pixelband++, bandindex += pixelsperband)
{
- 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);
+ pixelbgra8 = pixelsbgra8 + 4*bandindex;
+ bandpixel = highpixels + 4*bandindex;
+ c[0] = (int)(bandpixel[0]*256.0f);
+ c[1] = (int)(bandpixel[1]*256.0f);
+ c[2] = (int)(bandpixel[2]*256.0f);
+ c[3] = (int)(bandpixel[3]*256.0f);
+ pixelbgra8[2] = (unsigned char)bound(0, c[0], 255);
+ pixelbgra8[1] = (unsigned char)bound(0, c[1], 255);
+ pixelbgra8[0] = (unsigned char)bound(0, c[2], 255);
+ pixelbgra8[3] = (unsigned char)bound(0, c[3], 255);
}
- pixel[2] = (unsigned char)bound(0, c[0], 255);
- pixel[1] = (unsigned char)bound(0, c[1], 255);
- pixel[0] = (unsigned char)bound(0, c[2], 255);
- pixel[3] = (unsigned char)bound(0, c[3], 255);
}
}
}
}
- }
- if (!r_shadow_bouncegrid_state.createtexture)
- R_UpdateTexture(r_shadow_bouncegrid_state.texture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
- else
- {
- if (r_shadow_bouncegrid_state.texture)
- R_FreeTexture(r_shadow_bouncegrid_state.texture);
- r_shadow_bouncegrid_state.texture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*pixelbands, pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
+ if (!r_shadow_bouncegrid_state.createtexture)
+ R_UpdateTexture(r_shadow_bouncegrid_state.texture, pixelsbgra8, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
+ else
+ r_shadow_bouncegrid_state.texture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*pixelbands, pixelsbgra8, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
+ break;
+ case 1:
+ pixelsrgba16f = (unsigned short *)R_FrameData_Alloc(r_shadow_bouncegrid_state.numpixels * sizeof(unsigned short[4]));
+ memset(pixelsrgba16f, 0, r_shadow_bouncegrid_state.numpixels * sizeof(unsigned short[4]));
+ for (z = 1;z < resolution[2]-1;z++)
+ {
+ for (y = 1;y < resolution[1]-1;y++)
+ {
+ x = 1;
+ pixelband = 0;
+ index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
+ highpixel = highpixels + 4*index;
+ for (;x < resolution[0]-1;x++, index++, highpixel += 4)
+ {
+ // only convert pixels that were hit by photons
+ if (VectorLength2(highpixel))
+ {
+ // process all of the pixelbands for this pixel
+ for (pixelband = 0, bandindex = index;pixelband < pixelbands;pixelband++, bandindex += pixelsperband)
+ {
+ // time to have fun with IEEE 754 bit hacking...
+ union {
+ float f[4];
+ unsigned int raw[4];
+ } u;
+ pixelrgba16f = pixelsrgba16f + 4*bandindex;
+ bandpixel = highpixels + 4*bandindex;
+ VectorCopy4(bandpixel, u.f);
+ VectorCopy4(u.raw, c);
+ // this math supports negative numbers, snaps denormals to zero
+ //pixelrgba16f[0] = (unsigned short)(((c[0] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[0] - 0x38000000) >> 13) & 0x7FFF) | ((c[0] >> 16) & 0x8000));
+ //pixelrgba16f[1] = (unsigned short)(((c[1] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[1] - 0x38000000) >> 13) & 0x7FFF) | ((c[1] >> 16) & 0x8000));
+ //pixelrgba16f[2] = (unsigned short)(((c[2] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[2] - 0x38000000) >> 13) & 0x7FFF) | ((c[2] >> 16) & 0x8000));
+ //pixelrgba16f[3] = (unsigned short)(((c[3] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[3] - 0x38000000) >> 13) & 0x7FFF) | ((c[3] >> 16) & 0x8000));
+ // this math does not support negative
+ pixelrgba16f[0] = (unsigned short)((c[0] < 0x38000000) ? 0 : ((c[0] - 0x38000000) >> 13));
+ pixelrgba16f[1] = (unsigned short)((c[1] < 0x38000000) ? 0 : ((c[1] - 0x38000000) >> 13));
+ pixelrgba16f[2] = (unsigned short)((c[2] < 0x38000000) ? 0 : ((c[2] - 0x38000000) >> 13));
+ pixelrgba16f[3] = (unsigned short)((c[3] < 0x38000000) ? 0 : ((c[3] - 0x38000000) >> 13));
+ }
+ }
+ }
+ }
+ }
+
+ if (!r_shadow_bouncegrid_state.createtexture)
+ R_UpdateTexture(r_shadow_bouncegrid_state.texture, (const unsigned char *)pixelsrgba16f, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
+ else
+ r_shadow_bouncegrid_state.texture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*pixelbands, (const unsigned char *)pixelsrgba16f, TEXTYPE_COLORBUFFER16F, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
+ break;
+ case 2:
+ // our native format happens to match, so this is easy.
+ pixelsrgba32f = highpixels;
+
+ if (!r_shadow_bouncegrid_state.createtexture)
+ R_UpdateTexture(r_shadow_bouncegrid_state.texture, (const unsigned char *)pixelsrgba32f, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
+ else
+ r_shadow_bouncegrid_state.texture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*pixelbands, (const unsigned char *)pixelsrgba32f, TEXTYPE_COLORBUFFER32F, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
+ break;
}
+
r_shadow_bouncegrid_state.lastupdatetime = realtime;
}
static void R_Shadow_BounceGrid_TracePhotons(r_shadow_bouncegrid_settings_t settings, unsigned int range, unsigned int range1, unsigned int range2, float photonscaling, int flag)
{
+ vec3_t bouncerandom[10];
dlight_t *light;
int bouncecount;
int hitsupercontentsmask;
+ int skipsupercontentsmask;
int maxbounce;
int shootparticles;
int shotparticles;
//trace_t cliptrace3;
unsigned int lightindex;
unsigned int seed = (unsigned int)(realtime * 1000.0f);
+ randomseed_t randomseed;
vec3_t shotcolor;
vec3_t baseshotcolor;
vec3_t surfcolor;
vec_t s;
rtlight_t *rtlight;
- // we'll need somewhere to store these
+ Math_RandomSeed_FromInt(&randomseed, seed);
+
r_shadow_bouncegrid_state.numsplatpaths = 0;
r_shadow_bouncegrid_state.splatpaths = (r_shadow_bouncegrid_splatpath_t *)R_FrameData_Alloc(sizeof(r_shadow_bouncegrid_splatpath_t) * r_shadow_bouncegrid_state.maxsplatpaths);
hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
else
hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
+ skipsupercontentsmask = SUPERCONTENTS_SKY; // this allows the e1m5 sky shadow to work by ignoring the sky surfaces
maxbounce = settings.maxbounce;
for (lightindex = 0;lightindex < range2;lightindex++)
VectorScale(rtlight->photoncolor, s, baseshotcolor);
r_refdef.stats[r_stat_bouncegrid_lights]++;
r_refdef.stats[r_stat_bouncegrid_particles] += shootparticles;
+ switch (settings.stablerandom)
+ {
+ default:
+ break;
+ case 1:
+ Math_RandomSeed_FromInt(&randomseed, lightindex * 11937);
+ // prime the random number generator a bit
+ Math_crandomf(&randomseed);
+ break;
+ case 2:
+ seed = lightindex * 11937;
+ // prime the random number generator a bit
+ lhcheeserand(seed);
+ break;
+ }
for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
{
- if (settings.stablerandom > 0)
- seed = lightindex * 11937 + shotparticles;
VectorCopy(baseshotcolor, shotcolor);
VectorCopy(rtlight->shadoworigin, clipstart);
- if (settings.stablerandom < 0)
+ switch (settings.stablerandom)
+ {
+ default:
+ case 0:
VectorRandom(clipend);
- else
- VectorCheeseRandom(clipend);
+ if (settings.bounceanglediffuse)
+ {
+ // we want random to be stable, so we still have to do all the random we would have done
+ for (bouncecount = 0; bouncecount < maxbounce; bouncecount++)
+ VectorRandom(bouncerandom[bouncecount]);
+ }
+ break;
+ case -1:
+ case 1:
+ VectorLehmerRandom(&randomseed, clipend);
+ if (settings.bounceanglediffuse)
+ {
+ // we want random to be stable, so we still have to do all the random we would have done
+ for (bouncecount = 0; bouncecount < maxbounce; bouncecount++)
+ VectorLehmerRandom(&randomseed, bouncerandom[bouncecount]);
+ }
+ break;
+ case -2:
+ case 2:
+ VectorCheeseRandom(seed, clipend);
+ if (settings.bounceanglediffuse)
+ {
+ // we want random to be stable, so we still have to do all the random we would have done
+ for (bouncecount = 0; bouncecount < maxbounce; bouncecount++)
+ VectorCheeseRandom(seed, bouncerandom[bouncecount]);
+ }
+ break;
+ }
VectorMA(clipstart, radius, clipend, clipend);
for (bouncecount = 0;;bouncecount++)
{
r_refdef.stats[r_stat_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);
- if (settings.staticmode)
+ if (settings.staticmode || settings.stablerandom <= 0)
{
// static mode fires a LOT of rays but none of them are identical, so they are not cached
- cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, collision_extendmovelength.value, true, false, NULL, true, true);
+ // non-stable random in dynamic mode also never reuses a direction, so there's no reason to cache it
+ cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, skipsupercontentsmask, collision_extendmovelength.value, true, false, NULL, true, true);
}
else
{
// dynamic mode fires many rays and most will match the cache from the previous frame
- cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask);
+ cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask, skipsupercontentsmask);
}
if (bouncecount > 0 || settings.includedirectlighting)
{
vec3_t hitpos;
VectorCopy(cliptrace.endpos, hitpos);
- R_shadow_BounceGrid_AddSplatPath(clipstart, hitpos, shotcolor);
+ R_Shadow_BounceGrid_AddSplatPath(clipstart, hitpos, shotcolor);
}
if (cliptrace.fraction >= 1.0f)
break;
{
// random direction, primarily along plane normal
s = VectorDistance(cliptrace.endpos, clipend);
- if (settings.stablerandom < 0)
- VectorRandom(clipend);
- else
- VectorCheeseRandom(clipend);
- VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
+ VectorMA(cliptrace.plane.normal, 0.95f, bouncerandom[bouncecount], clipend);
VectorNormalize(clipend);
VectorScale(clipend, s, clipend);
}
R_FreeTexture(r_shadow_bouncegrid_state.texture);
r_shadow_bouncegrid_state.texture = NULL;
}
- if (r_shadow_bouncegrid_state.pixels)
- Mem_Free(r_shadow_bouncegrid_state.pixels);
- r_shadow_bouncegrid_state.pixels = NULL;
- if (r_shadow_bouncegrid_state.highpixels)
- Mem_Free(r_shadow_bouncegrid_state.highpixels);
- r_shadow_bouncegrid_state.highpixels = NULL;
r_shadow_bouncegrid_state.numpixels = 0;
r_shadow_bouncegrid_state.directional = false;
}
// if all the settings seem identical to the previous update, return
- if (r_shadow_bouncegrid_state.texture && (settings.staticmode || realtime < r_shadow_bouncegrid_state.lastupdatetime + r_shadow_bouncegrid_updateinterval.value) && !settingschanged)
+ if (r_shadow_bouncegrid_state.texture && (settings.staticmode || realtime < r_shadow_bouncegrid_state.lastupdatetime + r_shadow_bouncegrid_dynamic_updateinterval.value) && !settingschanged)
return;
// store the new settings
// trace the photons from lights and accumulate illumination
R_Shadow_BounceGrid_TracePhotons(settings, range, range1, range2, photonscaling, flag);
- // clear the pixels[] and highpixels[] arrays, it is important that we
- // clear pixels[] now because we do tricks with marking pixels as needing
- // conversion, even though the source of truth data is in highpixels[]
+ // clear the texture
R_Shadow_BounceGrid_ClearPixels();
-
- // sort and accumulate the light splatting in the texture
+
+ // accumulate the light splatting into texture
R_Shadow_BounceGrid_PerformSplats();
- // convert the pixels that were marked and upload the texture
+ // apply a mild blur filter to the texture
+ R_Shadow_BounceGrid_BlurPixels();
+
+ // convert the pixels to lower precision and upload the texture
R_Shadow_BounceGrid_ConvertPixelsAndUpload();
}
matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
Matrix4x4_Abs(&radiustolight);
- r_shadow_shadowmaplod = 0;
- for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
- if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
- r_shadow_shadowmaplod = i;
-
size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
}
- //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
+ //Con_Printf("distance %f lodlinear %i size %i\n", distance, lodlinear, size);
// render shadow casters into 6 sided depth texture
for (side = 0;side < 6;side++) if (receivermask & (1 << side))
else
{
// FIXME: these traces should scan all render entities instead of cl.world
- if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
return;
}
VectorScale(rtlight->currentcolor, cscale, color);
if (rating >= 0.95)
{
rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
- if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1.0f)
+ if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1.0f)
{
bestrating = rating;
best = light;
vec3_t dest, endpos;
trace_t trace;
VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
- trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, collision_extendmovelength.value, true, false, NULL, false, true);
+ trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true);
if (trace.fraction < 1)
{
dist = trace.fraction * r_editlights_cursordistance.value;
if (f <= 0)
continue;
// todo: add to both ambient and diffuse
- if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
+ if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
VectorMA(color, f, light->currentcolor, color);
}
}
if (f <= 0)
continue;
// todo: add to both ambient and diffuse
- if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
+ if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
VectorMA(color, f, light->color, color);
}
}
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, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
continue;
// scale down intensity to add to both ambient and diffuse
//intensity *= 0.5f;
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, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
continue;
// scale down intensity to add to both ambient and diffuse
//intensity *= 0.5f;
projects / xonotic / darkplaces.git / blobdiff