0dbcdfab36906d321d41382cbb2a5de007411f8c
[xonotic/darkplaces.git] / r_shadow.c
1 #include "quakedef.h"
2 #include "r_shadow.h"
3 #include "cl_collision.h"
4 #include "portals.h"
5 #include "image.h"
6
7 static void R_Shadow_EditLights_Init(void);
8
9 typedef enum r_shadow_rendermode_e
10 {
11         R_SHADOW_RENDERMODE_NONE,
12         R_SHADOW_RENDERMODE_ZPASS_STENCIL,
13         R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
14         R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
15         R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
16         R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
17         R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
18         R_SHADOW_RENDERMODE_LIGHT_GLSL,
19         R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
20         R_SHADOW_RENDERMODE_VISIBLELIGHTING,
21         R_SHADOW_RENDERMODE_SHADOWMAP2D
22 }
23 r_shadow_rendermode_t;
24
25 typedef enum r_shadow_shadowmode_e
26 {
27         R_SHADOW_SHADOWMODE_SHADOWMAP2D
28 }
29 r_shadow_shadowmode_t;
30
31 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
32 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
33 int r_shadow_scenemaxlights;
34 int r_shadow_scenenumlights;
35 rtlight_t **r_shadow_scenelightlist; // includes both static lights and dlights, as filtered by appropriate flags
36 qboolean r_shadow_usingshadowmap2d;
37 qboolean r_shadow_usingshadowmaportho;
38 int r_shadow_shadowmapside;
39 float r_shadow_lightshadowmap_texturescale[4]; // xy = scale, zw = offset
40 float r_shadow_lightshadowmap_parameters[4]; // x = frustum width in pixels (excludes border), y = z scale, z = size of viewport, w = z center
41 float r_shadow_modelshadowmap_texturescale[4]; // xy = scale, zw = offset
42 float r_shadow_modelshadowmap_parameters[4]; // xyz = scale, w = shadow brightness
43 #if 0
44 int r_shadow_drawbuffer;
45 int r_shadow_readbuffer;
46 #endif
47 int r_shadow_cullface_front, r_shadow_cullface_back;
48 GLuint r_shadow_fbo2d;
49 r_shadow_shadowmode_t r_shadow_shadowmode;
50 int r_shadow_shadowmapfilterquality;
51 int r_shadow_shadowmapdepthbits;
52 int r_shadow_shadowmapmaxsize;
53 int r_shadow_shadowmaptexturesize;
54 qboolean r_shadow_shadowmapvsdct;
55 qboolean r_shadow_shadowmapsampler;
56 qboolean r_shadow_shadowmapshadowsampler;
57 int r_shadow_shadowmappcf;
58 int r_shadow_shadowmapborder;
59 matrix4x4_t r_shadow_shadowmapmatrix;
60 int r_shadow_lightscissor[4];
61 qboolean r_shadow_usingdeferredprepass;
62 qboolean r_shadow_shadowmapdepthtexture;
63 mod_alloclightmap_state_t r_shadow_shadowmapatlas_state;
64 int r_shadow_shadowmapatlas_modelshadows_x;
65 int r_shadow_shadowmapatlas_modelshadows_y;
66 int r_shadow_shadowmapatlas_modelshadows_size;
67 int maxshadowtriangles;
68 int *shadowelements;
69
70 int maxshadowvertices;
71 float *shadowvertex3f;
72
73 int maxshadowmark;
74 int numshadowmark;
75 int *shadowmark;
76 int *shadowmarklist;
77 int shadowmarkcount;
78
79 int maxshadowsides;
80 int numshadowsides;
81 unsigned char *shadowsides;
82 int *shadowsideslist;
83
84 int maxvertexupdate;
85 int *vertexupdate;
86 int *vertexremap;
87 int vertexupdatenum;
88
89 int r_shadow_buffer_numleafpvsbytes;
90 unsigned char *r_shadow_buffer_visitingleafpvs;
91 unsigned char *r_shadow_buffer_leafpvs;
92 int *r_shadow_buffer_leaflist;
93
94 int r_shadow_buffer_numsurfacepvsbytes;
95 unsigned char *r_shadow_buffer_surfacepvs;
96 int *r_shadow_buffer_surfacelist;
97 unsigned char *r_shadow_buffer_surfacesides;
98
99 int r_shadow_buffer_numshadowtrispvsbytes;
100 unsigned char *r_shadow_buffer_shadowtrispvs;
101 int r_shadow_buffer_numlighttrispvsbytes;
102 unsigned char *r_shadow_buffer_lighttrispvs;
103
104 rtexturepool_t *r_shadow_texturepool;
105 rtexture_t *r_shadow_attenuationgradienttexture;
106 skinframe_t *r_shadow_lightcorona;
107 rtexture_t *r_shadow_shadowmap2ddepthbuffer;
108 rtexture_t *r_shadow_shadowmap2ddepthtexture;
109 rtexture_t *r_shadow_shadowmapvsdcttexture;
110
111 GLuint r_shadow_prepassgeometryfbo;
112 GLuint r_shadow_prepasslightingdiffusespecularfbo;
113 GLuint r_shadow_prepasslightingdiffusefbo;
114 int r_shadow_prepass_width;
115 int r_shadow_prepass_height;
116 rtexture_t *r_shadow_prepassgeometrydepthbuffer;
117 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
118 rtexture_t *r_shadow_prepasslightingdiffusetexture;
119 rtexture_t *r_shadow_prepasslightingspeculartexture;
120
121 int r_shadow_viewfbo;
122 rtexture_t *r_shadow_viewdepthtexture;
123 rtexture_t *r_shadow_viewcolortexture;
124 int r_shadow_viewx;
125 int r_shadow_viewy;
126 int r_shadow_viewwidth;
127 int r_shadow_viewheight;
128
129 // lights are reloaded when this changes
130 char r_shadow_mapname[MAX_QPATH];
131
132 // buffer for doing corona fading
133 unsigned int r_shadow_occlusion_buf = 0;
134
135 // used only for light filters (cubemaps)
136 rtexturepool_t *r_shadow_filters_texturepool;
137
138 cvar_t r_shadow_bumpscale_basetexture = {CVAR_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"};
139 cvar_t r_shadow_bumpscale_bumpmap = {CVAR_CLIENT, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
140 cvar_t r_shadow_debuglight = {CVAR_CLIENT, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
141 cvar_t r_shadow_deferred = {CVAR_CLIENT | 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"};
142 cvar_t r_shadow_usebihculling = {CVAR_CLIENT, "r_shadow_usebihculling", "1", "use BIH (Bounding Interval Hierarchy) for culling lit surfaces instead of BSP (Binary Space Partitioning)"};
143 cvar_t r_shadow_usenormalmap = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
144 cvar_t r_shadow_gloss = {CVAR_CLIENT | CVAR_SAVE, "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)"};
145 cvar_t r_shadow_gloss2intensity = {CVAR_CLIENT, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
146 cvar_t r_shadow_glossintensity = {CVAR_CLIENT, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
147 cvar_t r_shadow_glossexponent = {CVAR_CLIENT, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
148 cvar_t r_shadow_gloss2exponent = {CVAR_CLIENT, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
149 cvar_t r_shadow_glossexact = {CVAR_CLIENT, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
150 cvar_t r_shadow_lightattenuationdividebias = {CVAR_CLIENT, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
151 cvar_t r_shadow_lightattenuationlinearscale = {CVAR_CLIENT, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
152 cvar_t r_shadow_lightintensityscale = {CVAR_CLIENT, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
153 cvar_t r_shadow_lightradiusscale = {CVAR_CLIENT, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
154 cvar_t r_shadow_projectdistance = {CVAR_CLIENT, "r_shadow_projectdistance", "0", "how far to cast shadows"};
155 cvar_t r_shadow_frontsidecasting = {CVAR_CLIENT, "r_shadow_frontsidecasting", "1", "whether to cast shadows from illuminated triangles (front side of model) or unlit triangles (back side of model)"};
156 cvar_t r_shadow_realtime_dlight = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
157 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
158 cvar_t r_shadow_realtime_dlight_svbspculling = {CVAR_CLIENT, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
159 cvar_t r_shadow_realtime_dlight_portalculling = {CVAR_CLIENT, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
160 cvar_t r_shadow_realtime_world = {CVAR_CLIENT | CVAR_SAVE, "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)"};
161 cvar_t r_shadow_realtime_world_importlightentitiesfrommap = {CVAR_CLIENT, "r_shadow_realtime_world_importlightentitiesfrommap", "1", "load lights from .ent file or map entities at startup if no .rtlights or .lights file is present (if set to 2, always use the .ent or map entities)"};
162 cvar_t r_shadow_realtime_world_lightmaps = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};
163 cvar_t r_shadow_realtime_world_shadows = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
164 cvar_t r_shadow_realtime_world_compile = {CVAR_CLIENT, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
165 cvar_t r_shadow_realtime_world_compileshadow = {CVAR_CLIENT, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};
166 cvar_t r_shadow_realtime_world_compilesvbsp = {CVAR_CLIENT, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};
167 cvar_t r_shadow_realtime_world_compileportalculling = {CVAR_CLIENT, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
168 cvar_t r_shadow_scissor = {CVAR_CLIENT, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
169 cvar_t r_shadow_shadowmapping = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping", "1", "enables use of shadowmapping (shadow rendering by depth texture sampling)"};
170 cvar_t r_shadow_shadowmapping_filterquality = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_filterquality", "-1", "shadowmap filter modes: -1 = auto-select, 0 = no filtering, 1 = bilinear, 2 = bilinear 2x2 blur (fast), 3 = 3x3 blur (moderate), 4 = 4x4 blur (slow)"};
171 cvar_t r_shadow_shadowmapping_useshadowsampler = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_useshadowsampler", "1", "whether to use sampler2DShadow if available"};
172 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
173 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
174 cvar_t r_shadow_shadowmapping_minsize = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "limit of shadowmap side size - must be at least r_shadow_shadowmapping_bordersize+2"};
175 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "limit of shadowmap side size - can not be more than 1/8th of atlassize because lights store 6 sides (2x3 grid) and sometimes 12 sides (4x3 grid for shadows from EF_NOSELFSHADOW entities) and there are multiple lights..."};
176 cvar_t r_shadow_shadowmapping_texturesize = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_texturesize", "8192", "size of shadowmap atlas texture - all shadowmaps are packed into this texture at frame start"};
177 cvar_t r_shadow_shadowmapping_precision = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_precision", "1", "makes shadowmaps have a maximum resolution of this number of pixels per light source radius unit such that, for example, at precision 0.5 a light with radius 200 will have a maximum resolution of 100 pixels"};
178 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
179 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
180 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "5", "shadowmap size bias for filtering"};
181 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
182 cvar_t r_shadow_shadowmapping_bias = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
183 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
184 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
185 cvar_t r_shadow_sortsurfaces = {CVAR_CLIENT, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"};
186 cvar_t r_shadow_culllights_pvs = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_pvs", "1", "check if light overlaps any visible bsp leafs when determining if the light is visible"};
187 cvar_t r_shadow_culllights_trace = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace", "1", "use raytraces from the eye to random places within light bounds to determine if the light is visible"};
188 cvar_t r_shadow_culllights_trace_eyejitter = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_eyejitter", "16", "offset eye location randomly by this much"};
189 cvar_t r_shadow_culllights_trace_enlarge = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_enlarge", "0", "make light bounds bigger by *(1.0+enlarge)"};
190 cvar_t r_shadow_culllights_trace_expand = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_expand", "8", "make light bounds bigger by this many units"};
191 cvar_t r_shadow_culllights_trace_pad = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_pad", "8", "accept traces that hit within this many units of the light bounds"};
192 cvar_t r_shadow_culllights_trace_samples = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_samples", "16", "use this many traces to random positions (in addition to center trace)"};
193 cvar_t r_shadow_culllights_trace_tempsamples = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_tempsamples", "16", "use this many traces if the light was created by csqc (no inter-frame caching), -1 disables the check (to avoid flicker entirely)"};
194 cvar_t r_shadow_culllights_trace_delay = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_culllights_trace_delay", "1", "light will be considered visible for this many seconds after any trace connects"};
195 cvar_t r_shadow_bouncegrid = {CVAR_CLIENT | 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)"};
196 cvar_t r_shadow_bouncegrid_blur = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_blur", "0", "apply a 1-radius blur on bouncegrid to denoise it and deal with boundary issues with surfaces"};
197 cvar_t r_shadow_bouncegrid_dynamic_bounceminimumintensity = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_bounceminimumintensity", "0.05", "stop bouncing once intensity drops below this fraction of the original particle color"};
198 cvar_t r_shadow_bouncegrid_dynamic_culllightpaths = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_culllightpaths", "0", "skip accumulating light in the bouncegrid texture where the light paths are out of view (dynamic mode only)"};
199 cvar_t r_shadow_bouncegrid_dynamic_directionalshading = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_directionalshading", "1", "use diffuse shading rather than ambient, 3D texture becomes 8x as many pixels to hold the additional data"};
200 cvar_t r_shadow_bouncegrid_dynamic_dlightparticlemultiplier = {CVAR_CLIENT | 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"};
201 cvar_t r_shadow_bouncegrid_dynamic_hitmodels = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
202 cvar_t r_shadow_bouncegrid_dynamic_lightradiusscale = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_lightradiusscale", "5", "particles stop at this fraction of light radius (can be more than 1)"};
203 cvar_t r_shadow_bouncegrid_dynamic_maxbounce = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_maxbounce", "5", "maximum number of bounces for a particle (minimum is 0)"};
204 cvar_t r_shadow_bouncegrid_dynamic_maxphotons = {CVAR_CLIENT | 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"};
205 cvar_t r_shadow_bouncegrid_dynamic_quality = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_quality", "1", "amount of photons that should be fired (this is multiplied by spacing ^ 2 to make it adaptive with spacing changes)"};
206 cvar_t r_shadow_bouncegrid_dynamic_spacing = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_spacing", "64", "unit size of bouncegrid pixel"};
207 cvar_t r_shadow_bouncegrid_dynamic_updateinterval = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_updateinterval", "0", "update bouncegrid texture once per this many seconds, useful values are 0, 0.05, or 1000000"};
208 cvar_t r_shadow_bouncegrid_dynamic_x = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_x", "64", "maximum texture size of bouncegrid on X axis"};
209 cvar_t r_shadow_bouncegrid_dynamic_y = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_y", "64", "maximum texture size of bouncegrid on Y axis"};
210 cvar_t r_shadow_bouncegrid_dynamic_z = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_dynamic_z", "32", "maximum texture size of bouncegrid on Z axis"};
211 cvar_t r_shadow_bouncegrid_floatcolors = {CVAR_CLIENT | 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"};
212 cvar_t r_shadow_bouncegrid_includedirectlighting = {CVAR_CLIENT | 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)"};
213 cvar_t r_shadow_bouncegrid_intensity = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
214 cvar_t r_shadow_bouncegrid_lightpathsize = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_lightpathsize", "64", "radius (in game units) of the light path for accumulation of light in the bouncegrid texture"};
215 cvar_t r_shadow_bouncegrid_normalizevectors = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_normalizevectors", "1", "normalize random vectors (otherwise their length can vary, which dims the lighting further from the light)"};
216 cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_CLIENT | 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"};
217 cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "1", "brightness of particles contributing to bouncegrid texture"};
218 cvar_t r_shadow_bouncegrid_rng_seed = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_rng_seed", "0", "0+ = use this number as RNG seed, -1 = use time instead for disco-like craziness in dynamic mode"};
219 cvar_t r_shadow_bouncegrid_rng_type = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_rng_type", "0", "0 = Lehmer 128bit RNG (slow but high quality), 1 = lhcheeserand 32bit RNG (quick)"};
220 cvar_t r_shadow_bouncegrid_static = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
221 cvar_t r_shadow_bouncegrid_static_bounceminimumintensity = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_bounceminimumintensity", "0.01", "stop bouncing once intensity drops below this fraction of the original particle color"};
222 cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
223 cvar_t r_shadow_bouncegrid_static_lightradiusscale = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_lightradiusscale", "5", "particles stop at this fraction of light radius (can be more than 1) when in static mode"};
224 cvar_t r_shadow_bouncegrid_static_maxbounce = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_maxbounce", "5", "maximum number of bounces for a particle (minimum is 0) in static mode"};
225 cvar_t r_shadow_bouncegrid_static_maxphotons = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_maxphotons", "250000", "upper bound on photons in static mode"};
226 cvar_t r_shadow_bouncegrid_static_quality = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_quality", "16", "amount of photons that should be fired (this is multiplied by spacing ^ 2 to make it adaptive with spacing changes)"};
227 cvar_t r_shadow_bouncegrid_static_spacing = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_static_spacing", "64", "unit size of bouncegrid pixel when in static mode"};
228 cvar_t r_shadow_bouncegrid_subsamples = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_subsamples", "1", "when generating the texture, sample this many points along each dimension (multisampling uses more compute but not more memory bandwidth)"};
229 cvar_t r_shadow_bouncegrid_threaded = {CVAR_CLIENT | CVAR_SAVE, "r_shadow_bouncegrid_threaded", "1", "enables use of taskqueue_maxthreads to perform the traces and slice rendering of bouncegrid"};
230 cvar_t r_coronas = {CVAR_CLIENT | CVAR_SAVE, "r_coronas", "0", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
231 cvar_t r_coronas_occlusionsizescale = {CVAR_CLIENT | CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksum the proportion of hidden pixels controls corona intensity"};
232 cvar_t r_coronas_occlusionquery = {CVAR_CLIENT | CVAR_SAVE, "r_coronas_occlusionquery", "0", "fades coronas according to visibility"};
233 cvar_t gl_flashblend = {CVAR_CLIENT | CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
234 cvar_t r_editlights = {CVAR_CLIENT, "r_editlights", "0", "enables .rtlights file editing mode"};
235 cvar_t r_editlights_cursordistance = {CVAR_CLIENT, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
236 cvar_t r_editlights_cursorpushback = {CVAR_CLIENT, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
237 cvar_t r_editlights_cursorpushoff = {CVAR_CLIENT, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
238 cvar_t r_editlights_cursorgrid = {CVAR_CLIENT, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
239 cvar_t r_editlights_quakelightsizescale = {CVAR_CLIENT | CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
240 cvar_t r_editlights_drawproperties = {CVAR_CLIENT, "r_editlights_drawproperties", "1", "draw properties of currently selected light"};
241 cvar_t r_editlights_current_origin = {CVAR_CLIENT, "r_editlights_current_origin", "0 0 0", "origin of selected light"};
242 cvar_t r_editlights_current_angles = {CVAR_CLIENT, "r_editlights_current_angles", "0 0 0", "angles of selected light"};
243 cvar_t r_editlights_current_color = {CVAR_CLIENT, "r_editlights_current_color", "1 1 1", "color of selected light"};
244 cvar_t r_editlights_current_radius = {CVAR_CLIENT, "r_editlights_current_radius", "0", "radius of selected light"};
245 cvar_t r_editlights_current_corona = {CVAR_CLIENT, "r_editlights_current_corona", "0", "corona intensity of selected light"};
246 cvar_t r_editlights_current_coronasize = {CVAR_CLIENT, "r_editlights_current_coronasize", "0", "corona size of selected light"};
247 cvar_t r_editlights_current_style = {CVAR_CLIENT, "r_editlights_current_style", "0", "style of selected light"};
248 cvar_t r_editlights_current_shadows = {CVAR_CLIENT, "r_editlights_current_shadows", "0", "shadows flag of selected light"};
249 cvar_t r_editlights_current_cubemap = {CVAR_CLIENT, "r_editlights_current_cubemap", "0", "cubemap of selected light"};
250 cvar_t r_editlights_current_ambient = {CVAR_CLIENT, "r_editlights_current_ambient", "0", "ambient intensity of selected light"};
251 cvar_t r_editlights_current_diffuse = {CVAR_CLIENT, "r_editlights_current_diffuse", "1", "diffuse intensity of selected light"};
252 cvar_t r_editlights_current_specular = {CVAR_CLIENT, "r_editlights_current_specular", "1", "specular intensity of selected light"};
253 cvar_t r_editlights_current_normalmode = {CVAR_CLIENT, "r_editlights_current_normalmode", "0", "normalmode flag of selected light"};
254 cvar_t r_editlights_current_realtimemode = {CVAR_CLIENT, "r_editlights_current_realtimemode", "0", "realtimemode flag of selected light"};
255
256 r_shadow_bouncegrid_state_t r_shadow_bouncegrid_state;
257
258 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
259 #define ATTENTABLESIZE 256
260 // 1D gradient, 2D circle and 3D sphere attenuation textures
261 #define ATTEN1DSIZE 32
262 #define ATTEN2DSIZE 64
263 #define ATTEN3DSIZE 32
264
265 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
266 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
267 static float r_shadow_attentable[ATTENTABLESIZE+1];
268
269 rtlight_t *r_shadow_compilingrtlight;
270 static memexpandablearray_t r_shadow_worldlightsarray;
271 dlight_t *r_shadow_selectedlight;
272 dlight_t r_shadow_bufferlight;
273 vec3_t r_editlights_cursorlocation;
274 qboolean r_editlights_lockcursor;
275
276 extern int con_vislines;
277
278 void R_Shadow_UncompileWorldLights(void);
279 void R_Shadow_ClearWorldLights(void);
280 void R_Shadow_SaveWorldLights(void);
281 void R_Shadow_LoadWorldLights(void);
282 void R_Shadow_LoadLightsFile(void);
283 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
284 void R_Shadow_EditLights_Reload_f(cmd_state_t *cmd);
285 static void R_Shadow_MakeTextures(void);
286
287 #define EDLIGHTSPRSIZE                  8
288 skinframe_t *r_editlights_sprcursor;
289 skinframe_t *r_editlights_sprlight;
290 skinframe_t *r_editlights_sprnoshadowlight;
291 skinframe_t *r_editlights_sprcubemaplight;
292 skinframe_t *r_editlights_sprcubemapnoshadowlight;
293 skinframe_t *r_editlights_sprselection;
294
295 static void R_Shadow_DrawModelShadowMaps(void);
296 static void R_Shadow_MakeShadowMap(int texturesize);
297 static void R_Shadow_MakeVSDCT(void);
298 static void R_Shadow_SetShadowMode(void)
299 {
300         r_shadow_shadowmapborder = bound(1, r_shadow_shadowmapping_bordersize.integer, 16);
301         r_shadow_shadowmaptexturesize = bound(256, r_shadow_shadowmapping_texturesize.integer, (int)vid.maxtexturesize_2d);
302         r_shadow_shadowmapmaxsize = bound(r_shadow_shadowmapborder+2, r_shadow_shadowmapping_maxsize.integer, r_shadow_shadowmaptexturesize / 8);
303         r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL32;
304         r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
305         r_shadow_shadowmapshadowsampler = r_shadow_shadowmapping_useshadowsampler.integer != 0;
306         r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
307         r_shadow_shadowmapsampler = false;
308         r_shadow_shadowmappcf = 0;
309         r_shadow_shadowmapdepthtexture = r_fb.usedepthtextures;
310         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
311         Mod_AllocLightmap_Init(&r_shadow_shadowmapatlas_state, r_main_mempool, r_shadow_shadowmaptexturesize, r_shadow_shadowmaptexturesize);
312         if (r_shadow_shadowmapping.integer || r_shadow_deferred.integer)
313         {
314                 switch(vid.renderpath)
315                 {
316                 case RENDERPATH_GL32:
317                         if(r_shadow_shadowmapfilterquality < 0)
318                         {
319                                 if (!r_fb.usedepthtextures)
320                                         r_shadow_shadowmappcf = 1;
321                                 else if((strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD")) && r_shadow_shadowmapshadowsampler)
322                                 {
323                                         r_shadow_shadowmapsampler = true;
324                                         r_shadow_shadowmappcf = 1;
325                                 }
326                                 else if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
327                                         r_shadow_shadowmappcf = 1;
328                                 else if((strstr(gl_vendor, "ATI") || strstr(gl_vendor, "Advanced Micro Devices")) && !strstr(gl_renderer, "Mesa") && !strstr(gl_version, "Mesa"))
329                                         r_shadow_shadowmappcf = 1;
330                                 else
331                                         r_shadow_shadowmapsampler = r_shadow_shadowmapshadowsampler;
332                         }
333                         else
334                         {
335                 r_shadow_shadowmapsampler = r_shadow_shadowmapshadowsampler;
336                                 switch (r_shadow_shadowmapfilterquality)
337                                 {
338                                 case 1:
339                                         break;
340                                 case 2:
341                                         r_shadow_shadowmappcf = 1;
342                                         break;
343                                 case 3:
344                                         r_shadow_shadowmappcf = 1;
345                                         break;
346                                 case 4:
347                                         r_shadow_shadowmappcf = 2;
348                                         break;
349                                 }
350                         }
351                         if (!r_fb.usedepthtextures)
352                                 r_shadow_shadowmapsampler = false;
353                         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
354                         break;
355                 case RENDERPATH_GLES2:
356                         break;
357                 }
358         }
359
360         if(R_CompileShader_CheckStaticParms())
361                 R_GLSL_Restart_f(&cmd_client);
362 }
363
364 qboolean R_Shadow_ShadowMappingEnabled(void)
365 {
366         switch (r_shadow_shadowmode)
367         {
368         case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
369                 return true;
370         default:
371                 return false;
372         }
373 }
374
375 static void R_Shadow_FreeShadowMaps(void)
376 {
377         Mod_AllocLightmap_Free(&r_shadow_shadowmapatlas_state);
378
379         R_Shadow_SetShadowMode();
380
381         R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
382
383         r_shadow_fbo2d = 0;
384
385         if (r_shadow_shadowmap2ddepthtexture)
386                 R_FreeTexture(r_shadow_shadowmap2ddepthtexture);
387         r_shadow_shadowmap2ddepthtexture = NULL;
388
389         if (r_shadow_shadowmap2ddepthbuffer)
390                 R_FreeTexture(r_shadow_shadowmap2ddepthbuffer);
391         r_shadow_shadowmap2ddepthbuffer = NULL;
392
393         if (r_shadow_shadowmapvsdcttexture)
394                 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
395         r_shadow_shadowmapvsdcttexture = NULL;
396 }
397
398 static void r_shadow_start(void)
399 {
400         // allocate vertex processing arrays
401         memset(&r_shadow_bouncegrid_state, 0, sizeof(r_shadow_bouncegrid_state));
402         r_shadow_attenuationgradienttexture = NULL;
403         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
404         r_shadow_shadowmap2ddepthtexture = NULL;
405         r_shadow_shadowmap2ddepthbuffer = NULL;
406         r_shadow_shadowmapvsdcttexture = NULL;
407         r_shadow_shadowmapmaxsize = 0;
408         r_shadow_shadowmaptexturesize = 0;
409         r_shadow_shadowmapfilterquality = -1;
410         r_shadow_shadowmapdepthbits = 0;
411         r_shadow_shadowmapvsdct = false;
412         r_shadow_shadowmapsampler = false;
413         r_shadow_shadowmappcf = 0;
414         r_shadow_fbo2d = 0;
415
416         R_Shadow_FreeShadowMaps();
417
418         r_shadow_texturepool = NULL;
419         r_shadow_filters_texturepool = NULL;
420         R_Shadow_MakeTextures();
421         r_shadow_scenemaxlights = 0;
422         r_shadow_scenenumlights = 0;
423         r_shadow_scenelightlist = NULL;
424         maxshadowtriangles = 0;
425         shadowelements = NULL;
426         maxshadowvertices = 0;
427         shadowvertex3f = NULL;
428         maxvertexupdate = 0;
429         vertexupdate = NULL;
430         vertexremap = NULL;
431         vertexupdatenum = 0;
432         maxshadowmark = 0;
433         numshadowmark = 0;
434         shadowmark = NULL;
435         shadowmarklist = NULL;
436         shadowmarkcount = 0;
437         maxshadowsides = 0;
438         numshadowsides = 0;
439         shadowsides = NULL;
440         shadowsideslist = NULL;
441         r_shadow_buffer_numleafpvsbytes = 0;
442         r_shadow_buffer_visitingleafpvs = NULL;
443         r_shadow_buffer_leafpvs = NULL;
444         r_shadow_buffer_leaflist = NULL;
445         r_shadow_buffer_numsurfacepvsbytes = 0;
446         r_shadow_buffer_surfacepvs = NULL;
447         r_shadow_buffer_surfacelist = NULL;
448         r_shadow_buffer_surfacesides = NULL;
449         r_shadow_buffer_numshadowtrispvsbytes = 0;
450         r_shadow_buffer_shadowtrispvs = NULL;
451         r_shadow_buffer_numlighttrispvsbytes = 0;
452         r_shadow_buffer_lighttrispvs = NULL;
453
454         r_shadow_usingdeferredprepass = false;
455         r_shadow_prepass_width = r_shadow_prepass_height = 0;
456
457         // determine renderpath specific capabilities, we don't need to figure
458         // these out per frame...
459         switch(vid.renderpath)
460         {
461         case RENDERPATH_GL32:
462                 r_shadow_bouncegrid_state.allowdirectionalshading = true;
463                 r_shadow_bouncegrid_state.capable = true;
464                 break;
465         case RENDERPATH_GLES2:
466                 // for performance reasons, do not use directional shading on GLES devices
467                 r_shadow_bouncegrid_state.capable = true;
468                 break;
469         }
470 }
471
472 static void R_Shadow_FreeDeferred(void);
473 static void r_shadow_shutdown(void)
474 {
475         CHECKGLERROR
476         R_Shadow_UncompileWorldLights();
477
478         R_Shadow_FreeShadowMaps();
479
480         r_shadow_usingdeferredprepass = false;
481         if (r_shadow_prepass_width)
482                 R_Shadow_FreeDeferred();
483         r_shadow_prepass_width = r_shadow_prepass_height = 0;
484
485         CHECKGLERROR
486         r_shadow_scenemaxlights = 0;
487         r_shadow_scenenumlights = 0;
488         if (r_shadow_scenelightlist)
489                 Mem_Free(r_shadow_scenelightlist);
490         r_shadow_scenelightlist = NULL;
491         r_shadow_bouncegrid_state.highpixels = NULL;
492         if (r_shadow_bouncegrid_state.blurpixels[0]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[0]); r_shadow_bouncegrid_state.blurpixels[0] = NULL;
493         if (r_shadow_bouncegrid_state.blurpixels[1]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[1]); r_shadow_bouncegrid_state.blurpixels[1] = NULL;
494         if (r_shadow_bouncegrid_state.u8pixels) Mem_Free(r_shadow_bouncegrid_state.u8pixels); r_shadow_bouncegrid_state.u8pixels = NULL;
495         if (r_shadow_bouncegrid_state.fp16pixels) Mem_Free(r_shadow_bouncegrid_state.fp16pixels); r_shadow_bouncegrid_state.fp16pixels = NULL;
496         if (r_shadow_bouncegrid_state.photons) Mem_Free(r_shadow_bouncegrid_state.photons); r_shadow_bouncegrid_state.photons = NULL;
497         if (r_shadow_bouncegrid_state.photons_tasks) Mem_Free(r_shadow_bouncegrid_state.photons_tasks); r_shadow_bouncegrid_state.photons_tasks = NULL;
498         if (r_shadow_bouncegrid_state.slices_tasks) Mem_Free(r_shadow_bouncegrid_state.slices_tasks); r_shadow_bouncegrid_state.slices_tasks = NULL;
499         memset(&r_shadow_bouncegrid_state, 0, sizeof(r_shadow_bouncegrid_state));
500         r_shadow_attenuationgradienttexture = NULL;
501         R_FreeTexturePool(&r_shadow_texturepool);
502         R_FreeTexturePool(&r_shadow_filters_texturepool);
503         maxshadowtriangles = 0;
504         if (shadowelements)
505                 Mem_Free(shadowelements);
506         shadowelements = NULL;
507         if (shadowvertex3f)
508                 Mem_Free(shadowvertex3f);
509         shadowvertex3f = NULL;
510         maxvertexupdate = 0;
511         if (vertexupdate)
512                 Mem_Free(vertexupdate);
513         vertexupdate = NULL;
514         if (vertexremap)
515                 Mem_Free(vertexremap);
516         vertexremap = NULL;
517         vertexupdatenum = 0;
518         maxshadowmark = 0;
519         numshadowmark = 0;
520         if (shadowmark)
521                 Mem_Free(shadowmark);
522         shadowmark = NULL;
523         if (shadowmarklist)
524                 Mem_Free(shadowmarklist);
525         shadowmarklist = NULL;
526         shadowmarkcount = 0;
527         maxshadowsides = 0;
528         numshadowsides = 0;
529         if (shadowsides)
530                 Mem_Free(shadowsides);
531         shadowsides = NULL;
532         if (shadowsideslist)
533                 Mem_Free(shadowsideslist);
534         shadowsideslist = NULL;
535         r_shadow_buffer_numleafpvsbytes = 0;
536         if (r_shadow_buffer_visitingleafpvs)
537                 Mem_Free(r_shadow_buffer_visitingleafpvs);
538         r_shadow_buffer_visitingleafpvs = NULL;
539         if (r_shadow_buffer_leafpvs)
540                 Mem_Free(r_shadow_buffer_leafpvs);
541         r_shadow_buffer_leafpvs = NULL;
542         if (r_shadow_buffer_leaflist)
543                 Mem_Free(r_shadow_buffer_leaflist);
544         r_shadow_buffer_leaflist = NULL;
545         r_shadow_buffer_numsurfacepvsbytes = 0;
546         if (r_shadow_buffer_surfacepvs)
547                 Mem_Free(r_shadow_buffer_surfacepvs);
548         r_shadow_buffer_surfacepvs = NULL;
549         if (r_shadow_buffer_surfacelist)
550                 Mem_Free(r_shadow_buffer_surfacelist);
551         r_shadow_buffer_surfacelist = NULL;
552         if (r_shadow_buffer_surfacesides)
553                 Mem_Free(r_shadow_buffer_surfacesides);
554         r_shadow_buffer_surfacesides = NULL;
555         r_shadow_buffer_numshadowtrispvsbytes = 0;
556         if (r_shadow_buffer_shadowtrispvs)
557                 Mem_Free(r_shadow_buffer_shadowtrispvs);
558         r_shadow_buffer_numlighttrispvsbytes = 0;
559         if (r_shadow_buffer_lighttrispvs)
560                 Mem_Free(r_shadow_buffer_lighttrispvs);
561 }
562
563 static void r_shadow_newmap(void)
564 {
565         r_shadow_bouncegrid_state.highpixels = NULL;
566         if (r_shadow_bouncegrid_state.blurpixels[0]) { Mem_Free(r_shadow_bouncegrid_state.blurpixels[0]); r_shadow_bouncegrid_state.blurpixels[0] = NULL; }
567         if (r_shadow_bouncegrid_state.blurpixels[1]) { Mem_Free(r_shadow_bouncegrid_state.blurpixels[1]); r_shadow_bouncegrid_state.blurpixels[1] = NULL; }
568         if (r_shadow_bouncegrid_state.u8pixels) { Mem_Free(r_shadow_bouncegrid_state.u8pixels); r_shadow_bouncegrid_state.u8pixels = NULL; }
569         if (r_shadow_bouncegrid_state.fp16pixels) { Mem_Free(r_shadow_bouncegrid_state.fp16pixels); r_shadow_bouncegrid_state.fp16pixels = NULL; }
570         if (r_shadow_bouncegrid_state.photons) Mem_Free(r_shadow_bouncegrid_state.photons); r_shadow_bouncegrid_state.photons = NULL;
571         if (r_shadow_bouncegrid_state.photons_tasks) Mem_Free(r_shadow_bouncegrid_state.photons_tasks); r_shadow_bouncegrid_state.photons_tasks = NULL;
572         if (r_shadow_bouncegrid_state.slices_tasks) Mem_Free(r_shadow_bouncegrid_state.slices_tasks); r_shadow_bouncegrid_state.slices_tasks = NULL;
573
574         if (r_shadow_bouncegrid_state.texture)    { R_FreeTexture(r_shadow_bouncegrid_state.texture);r_shadow_bouncegrid_state.texture = NULL; }
575         if (r_shadow_lightcorona)                 { R_SkinFrame_MarkUsed(r_shadow_lightcorona); }
576         if (r_editlights_sprcursor)               { R_SkinFrame_MarkUsed(r_editlights_sprcursor); }
577         if (r_editlights_sprlight)                { R_SkinFrame_MarkUsed(r_editlights_sprlight); }
578         if (r_editlights_sprnoshadowlight)        { R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight); }
579         if (r_editlights_sprcubemaplight)         { R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight); }
580         if (r_editlights_sprcubemapnoshadowlight) { R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight); }
581         if (r_editlights_sprselection)            { R_SkinFrame_MarkUsed(r_editlights_sprselection); }
582         if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
583                 R_Shadow_EditLights_Reload_f(&cmd_client);
584 }
585
586 void R_Shadow_Init(void)
587 {
588         Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
589         Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
590         Cvar_RegisterVariable(&r_shadow_usebihculling);
591         Cvar_RegisterVariable(&r_shadow_usenormalmap);
592         Cvar_RegisterVariable(&r_shadow_debuglight);
593         Cvar_RegisterVariable(&r_shadow_deferred);
594         Cvar_RegisterVariable(&r_shadow_gloss);
595         Cvar_RegisterVariable(&r_shadow_gloss2intensity);
596         Cvar_RegisterVariable(&r_shadow_glossintensity);
597         Cvar_RegisterVariable(&r_shadow_glossexponent);
598         Cvar_RegisterVariable(&r_shadow_gloss2exponent);
599         Cvar_RegisterVariable(&r_shadow_glossexact);
600         Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
601         Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
602         Cvar_RegisterVariable(&r_shadow_lightintensityscale);
603         Cvar_RegisterVariable(&r_shadow_lightradiusscale);
604         Cvar_RegisterVariable(&r_shadow_projectdistance);
605         Cvar_RegisterVariable(&r_shadow_frontsidecasting);
606         Cvar_RegisterVariable(&r_shadow_realtime_world_importlightentitiesfrommap);
607         Cvar_RegisterVariable(&r_shadow_realtime_dlight);
608         Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
609         Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
610         Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
611         Cvar_RegisterVariable(&r_shadow_realtime_world);
612         Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
613         Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
614         Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
615         Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
616         Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
617         Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
618         Cvar_RegisterVariable(&r_shadow_scissor);
619         Cvar_RegisterVariable(&r_shadow_shadowmapping);
620         Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
621         Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
622         Cvar_RegisterVariable(&r_shadow_shadowmapping_useshadowsampler);
623         Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
624         Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
625         Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
626         Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
627         Cvar_RegisterVariable(&r_shadow_shadowmapping_texturesize);
628 //      Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
629 //      Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
630         Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
631         Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
632         Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
633         Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
634         Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
635         Cvar_RegisterVariable(&r_shadow_sortsurfaces);
636         Cvar_RegisterVariable(&r_shadow_culllights_pvs);
637         Cvar_RegisterVariable(&r_shadow_culllights_trace);
638         Cvar_RegisterVariable(&r_shadow_culllights_trace_eyejitter);
639         Cvar_RegisterVariable(&r_shadow_culllights_trace_enlarge);
640         Cvar_RegisterVariable(&r_shadow_culllights_trace_expand);
641         Cvar_RegisterVariable(&r_shadow_culllights_trace_pad);
642         Cvar_RegisterVariable(&r_shadow_culllights_trace_samples);
643         Cvar_RegisterVariable(&r_shadow_culllights_trace_tempsamples);
644         Cvar_RegisterVariable(&r_shadow_culllights_trace_delay);
645         Cvar_RegisterVariable(&r_shadow_bouncegrid);
646         Cvar_RegisterVariable(&r_shadow_bouncegrid_blur);
647         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_bounceminimumintensity);
648         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_culllightpaths);
649         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_directionalshading);
650         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_dlightparticlemultiplier);
651         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_hitmodels);
652         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_lightradiusscale);
653         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxbounce);
654         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxphotons);
655         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_quality);
656         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_spacing);
657         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_updateinterval);
658         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_x);
659         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_y);
660         Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_z);
661         Cvar_RegisterVariable(&r_shadow_bouncegrid_floatcolors);
662         Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
663         Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
664         Cvar_RegisterVariable(&r_shadow_bouncegrid_lightpathsize);
665         Cvar_RegisterVariable(&r_shadow_bouncegrid_normalizevectors);
666         Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
667         Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
668         Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_seed);
669         Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_type);
670         Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
671         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_bounceminimumintensity);
672         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
673         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
674         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
675         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxphotons);
676         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_quality);
677         Cvar_RegisterVariable(&r_shadow_bouncegrid_static_spacing);
678         Cvar_RegisterVariable(&r_shadow_bouncegrid_subsamples);
679         Cvar_RegisterVariable(&r_shadow_bouncegrid_threaded);
680         Cvar_RegisterVariable(&r_coronas);
681         Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
682         Cvar_RegisterVariable(&r_coronas_occlusionquery);
683         Cvar_RegisterVariable(&gl_flashblend);
684         R_Shadow_EditLights_Init();
685         Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
686         r_shadow_scenemaxlights = 0;
687         r_shadow_scenenumlights = 0;
688         r_shadow_scenelightlist = NULL;
689         maxshadowtriangles = 0;
690         shadowelements = NULL;
691         maxshadowvertices = 0;
692         shadowvertex3f = NULL;
693         maxvertexupdate = 0;
694         vertexupdate = NULL;
695         vertexremap = NULL;
696         vertexupdatenum = 0;
697         maxshadowmark = 0;
698         numshadowmark = 0;
699         shadowmark = NULL;
700         shadowmarklist = NULL;
701         shadowmarkcount = 0;
702         maxshadowsides = 0;
703         numshadowsides = 0;
704         shadowsides = NULL;
705         shadowsideslist = NULL;
706         r_shadow_buffer_numleafpvsbytes = 0;
707         r_shadow_buffer_visitingleafpvs = NULL;
708         r_shadow_buffer_leafpvs = NULL;
709         r_shadow_buffer_leaflist = NULL;
710         r_shadow_buffer_numsurfacepvsbytes = 0;
711         r_shadow_buffer_surfacepvs = NULL;
712         r_shadow_buffer_surfacelist = NULL;
713         r_shadow_buffer_surfacesides = NULL;
714         r_shadow_buffer_shadowtrispvs = NULL;
715         r_shadow_buffer_lighttrispvs = NULL;
716         R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
717 }
718
719 matrix4x4_t matrix_attenuationxyz =
720 {
721         {
722                 {0.5, 0.0, 0.0, 0.5},
723                 {0.0, 0.5, 0.0, 0.5},
724                 {0.0, 0.0, 0.5, 0.5},
725                 {0.0, 0.0, 0.0, 1.0}
726         }
727 };
728
729 matrix4x4_t matrix_attenuationz =
730 {
731         {
732                 {0.0, 0.0, 0.5, 0.5},
733                 {0.0, 0.0, 0.0, 0.5},
734                 {0.0, 0.0, 0.0, 0.5},
735                 {0.0, 0.0, 0.0, 1.0}
736         }
737 };
738
739 static void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
740 {
741         numvertices = ((numvertices + 255) & ~255) * vertscale;
742         numtriangles = ((numtriangles + 255) & ~255) * triscale;
743         // make sure shadowelements is big enough for this volume
744         if (maxshadowtriangles < numtriangles)
745         {
746                 maxshadowtriangles = numtriangles;
747                 if (shadowelements)
748                         Mem_Free(shadowelements);
749                 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
750         }
751         // make sure shadowvertex3f is big enough for this volume
752         if (maxshadowvertices < numvertices)
753         {
754                 maxshadowvertices = numvertices;
755                 if (shadowvertex3f)
756                         Mem_Free(shadowvertex3f);
757                 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
758         }
759 }
760
761 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
762 {
763         int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
764         int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
765         int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
766         int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
767         if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
768         {
769                 if (r_shadow_buffer_visitingleafpvs)
770                         Mem_Free(r_shadow_buffer_visitingleafpvs);
771                 if (r_shadow_buffer_leafpvs)
772                         Mem_Free(r_shadow_buffer_leafpvs);
773                 if (r_shadow_buffer_leaflist)
774                         Mem_Free(r_shadow_buffer_leaflist);
775                 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
776                 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
777                 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
778                 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
779         }
780         if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
781         {
782                 if (r_shadow_buffer_surfacepvs)
783                         Mem_Free(r_shadow_buffer_surfacepvs);
784                 if (r_shadow_buffer_surfacelist)
785                         Mem_Free(r_shadow_buffer_surfacelist);
786                 if (r_shadow_buffer_surfacesides)
787                         Mem_Free(r_shadow_buffer_surfacesides);
788                 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
789                 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
790                 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
791                 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
792         }
793         if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
794         {
795                 if (r_shadow_buffer_shadowtrispvs)
796                         Mem_Free(r_shadow_buffer_shadowtrispvs);
797                 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
798                 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
799         }
800         if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
801         {
802                 if (r_shadow_buffer_lighttrispvs)
803                         Mem_Free(r_shadow_buffer_lighttrispvs);
804                 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
805                 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
806         }
807 }
808
809 void R_Shadow_PrepareShadowMark(int numtris)
810 {
811         // make sure shadowmark is big enough for this volume
812         if (maxshadowmark < numtris)
813         {
814                 maxshadowmark = numtris;
815                 if (shadowmark)
816                         Mem_Free(shadowmark);
817                 if (shadowmarklist)
818                         Mem_Free(shadowmarklist);
819                 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
820                 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
821                 shadowmarkcount = 0;
822         }
823         shadowmarkcount++;
824         // if shadowmarkcount wrapped we clear the array and adjust accordingly
825         if (shadowmarkcount == 0)
826         {
827                 shadowmarkcount = 1;
828                 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
829         }
830         numshadowmark = 0;
831 }
832
833 void R_Shadow_PrepareShadowSides(int numtris)
834 {
835         if (maxshadowsides < numtris)
836         {
837                 maxshadowsides = numtris;
838                 if (shadowsides)
839                         Mem_Free(shadowsides);
840                 if (shadowsideslist)
841                         Mem_Free(shadowsideslist);
842                 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
843                 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
844         }
845         numshadowsides = 0;
846 }
847
848 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
849 {
850         // p1, p2, p3 are in the cubemap's local coordinate system
851         // bias = border/(size - border)
852         int mask = 0x3F;
853
854         float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
855                   dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
856                   dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
857         if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
858                 mask &= (3<<4)
859                         | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
860                         | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
861                         | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
862         if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
863                 mask &= (3<<4)
864                         | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
865                         | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))                    
866                         | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
867
868         dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
869         dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
870         dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
871         if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
872                 mask &= (3<<0)
873                         | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
874                         | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))                    
875                         | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
876         if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
877                 mask &= (3<<0)
878                         | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
879                         | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
880                         | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
881
882         dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
883         dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
884         dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
885         if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
886                 mask &= (3<<2)
887                         | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
888                         | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
889                         | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
890         if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
891                 mask &= (3<<2)
892                         | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
893                         | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
894                         | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
895
896         return mask;
897 }
898
899 static int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
900 {
901         vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
902         float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
903         int mask = 0x3F;
904
905         VectorSubtract(maxs, mins, radius);
906         VectorScale(radius, 0.5f, radius);
907         VectorAdd(mins, radius, center);
908         Matrix4x4_Transform(worldtolight, center, lightcenter);
909         Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
910         VectorSubtract(lightcenter, lightradius, pmin);
911         VectorAdd(lightcenter, lightradius, pmax);
912
913         dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
914         dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
915         if(ap1 > bias*an1 && ap2 > bias*an2)
916                 mask &= (3<<4)
917                         | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
918                         | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
919         if(an1 > bias*ap1 && an2 > bias*ap2)
920                 mask &= (3<<4)
921                         | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
922                         | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
923
924         dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
925         dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
926         if(ap1 > bias*an1 && ap2 > bias*an2)
927                 mask &= (3<<0)
928                         | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
929                         | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
930         if(an1 > bias*ap1 && an2 > bias*ap2)
931                 mask &= (3<<0)
932                         | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
933                         | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
934
935         dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
936         dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
937         if(ap1 > bias*an1 && ap2 > bias*an2)
938                 mask &= (3<<2)
939                         | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
940                         | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
941         if(an1 > bias*ap1 && an2 > bias*ap2)
942                 mask &= (3<<2)
943                         | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
944                         | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
945
946         return mask;
947 }
948
949 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
950
951 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
952 {
953         // p is in the cubemap's local coordinate system
954         // bias = border/(size - border)
955         float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
956         float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
957         float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
958         int mask = 0x3F;
959         if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
960         if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
961         if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
962         if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
963         if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
964         if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
965         return mask;
966 }
967
968 static int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
969 {
970         int i;
971         vec3_t o, p, n;
972         int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
973         float scale = (size - 2*border)/size, len;
974         float bias = border / (float)(size - border), dp, dn, ap, an;
975         // check if cone enclosing side would cross frustum plane
976         scale = 2 / (scale*scale + 2);
977         Matrix4x4_OriginFromMatrix(&rtlight->matrix_lighttoworld, o);
978         for (i = 0;i < 5;i++)
979         {
980                 if (PlaneDiff(o, &r_refdef.view.frustum[i]) > -0.03125)
981                         continue;
982                 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
983                 len = scale*VectorLength2(n);
984                 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
985                 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
986                 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
987         }
988         if (PlaneDiff(o, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
989         {
990                 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
991                 len = scale*VectorLength2(n);
992                 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
993                 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
994                 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
995         }
996         // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
997         // check if frustum corners/origin cross plane sides
998 #if 1
999         // infinite version, assumes frustum corners merely give direction and extend to infinite distance
1000         Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
1001         dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1002         masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1003         masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1004         dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1005         masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1006         masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1007         dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1008         masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1009         masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1010         for (i = 0;i < 4;i++)
1011         {
1012                 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
1013                 VectorSubtract(n, p, n);
1014                 dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
1015                 if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
1016                 if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
1017                 dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
1018                 if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
1019                 if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
1020                 dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
1021                 if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
1022                 if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
1023         }
1024 #else
1025         // finite version, assumes corners are a finite distance from origin dependent on far plane
1026         for (i = 0;i < 5;i++)
1027         {
1028                 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1029                 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1030                 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1031                 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1032                 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1033                 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1034                 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1035                 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1036                 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1037                 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1038         }
1039 #endif
1040         return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1041 }
1042
1043 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)
1044 {
1045         int t, tend;
1046         const int *e;
1047         const float *v[3];
1048         float normal[3];
1049         vec3_t p[3];
1050         float bias;
1051         int mask, surfacemask = 0;
1052         if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1053                 return 0;
1054         bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1055         tend = firsttriangle + numtris;
1056         if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1057         {
1058                 // surface box entirely inside light box, no box cull
1059                 if (projectdirection)
1060                 {
1061                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1062                         {
1063                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1064                                 TriangleNormal(v[0], v[1], v[2], normal);
1065                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1066                                 {
1067                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1068                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1069                                         surfacemask |= mask;
1070                                         if(totals)
1071                                         {
1072                                                 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;
1073                                                 shadowsides[numshadowsides] = mask;
1074                                                 shadowsideslist[numshadowsides++] = t;
1075                                         }
1076                                 }
1077                         }
1078                 }
1079                 else
1080                 {
1081                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1082                         {
1083                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,     v[2] = invertex3f + e[2] * 3;
1084                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1085                                 {
1086                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1087                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1088                                         surfacemask |= mask;
1089                                         if(totals)
1090                                         {
1091                                                 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;
1092                                                 shadowsides[numshadowsides] = mask;
1093                                                 shadowsideslist[numshadowsides++] = t;
1094                                         }
1095                                 }
1096                         }
1097                 }
1098         }
1099         else
1100         {
1101                 // surface box not entirely inside light box, cull each triangle
1102                 if (projectdirection)
1103                 {
1104                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1105                         {
1106                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,     v[2] = invertex3f + e[2] * 3;
1107                                 TriangleNormal(v[0], v[1], v[2], normal);
1108                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1109                                  && TriangleBBoxOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1110                                 {
1111                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1112                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1113                                         surfacemask |= mask;
1114                                         if(totals)
1115                                         {
1116                                                 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;
1117                                                 shadowsides[numshadowsides] = mask;
1118                                                 shadowsideslist[numshadowsides++] = t;
1119                                         }
1120                                 }
1121                         }
1122                 }
1123                 else
1124                 {
1125                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1126                         {
1127                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1128                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1129                                  && TriangleBBoxOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1130                                 {
1131                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1132                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1133                                         surfacemask |= mask;
1134                                         if(totals)
1135                                         {
1136                                                 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;
1137                                                 shadowsides[numshadowsides] = mask;
1138                                                 shadowsideslist[numshadowsides++] = t;
1139                                         }
1140                                 }
1141                         }
1142                 }
1143         }
1144         return surfacemask;
1145 }
1146
1147 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)
1148 {
1149         int i, j, outtriangles = 0;
1150         int *outelement3i[6];
1151         if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1152                 return;
1153         outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1154         // make sure shadowelements is big enough for this mesh
1155         if (maxshadowtriangles < outtriangles)
1156                 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1157
1158         // compute the offset and size of the separate index lists for each cubemap side
1159         outtriangles = 0;
1160         for (i = 0;i < 6;i++)
1161         {
1162                 outelement3i[i] = shadowelements + outtriangles * 3;
1163                 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1164                 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1165                 outtriangles += sidetotals[i];
1166         }
1167
1168         // gather up the (sparse) triangles into separate index lists for each cubemap side
1169         for (i = 0;i < numsidetris;i++)
1170         {
1171                 const int *element = elements + sidetris[i] * 3;
1172                 for (j = 0;j < 6;j++)
1173                 {
1174                         if (sides[i] & (1 << j))
1175                         {
1176                                 outelement3i[j][0] = element[0];
1177                                 outelement3i[j][1] = element[1];
1178                                 outelement3i[j][2] = element[2];
1179                                 outelement3i[j] += 3;
1180                         }
1181                 }
1182         }
1183
1184         Mod_ShadowMesh_AddMesh(r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, vertex3f, outtriangles, shadowelements);
1185 }
1186
1187 static void R_Shadow_MakeTextures_MakeCorona(void)
1188 {
1189         float dx, dy;
1190         int x, y, a;
1191         unsigned char pixels[32][32][4];
1192         for (y = 0;y < 32;y++)
1193         {
1194                 dy = (y - 15.5f) * (1.0f / 16.0f);
1195                 for (x = 0;x < 32;x++)
1196                 {
1197                         dx = (x - 15.5f) * (1.0f / 16.0f);
1198                         a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1199                         a = bound(0, a, 255);
1200                         pixels[y][x][0] = a;
1201                         pixels[y][x][1] = a;
1202                         pixels[y][x][2] = a;
1203                         pixels[y][x][3] = 255;
1204                 }
1205         }
1206         r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32, 0, 0, 0, false);
1207 }
1208
1209 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1210 {
1211         float dist = sqrt(x*x+y*y+z*z);
1212         float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1213         // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1214         return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1215 }
1216
1217 static void R_Shadow_MakeTextures(void)
1218 {
1219         int x;
1220         float intensity, dist;
1221         unsigned int *data;
1222         R_Shadow_FreeShadowMaps();
1223         R_FreeTexturePool(&r_shadow_texturepool);
1224         r_shadow_texturepool = R_AllocTexturePool();
1225         r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1226         r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1227         data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1228         // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1229         for (x = 0;x <= ATTENTABLESIZE;x++)
1230         {
1231                 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1232                 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1233                 r_shadow_attentable[x] = bound(0, intensity, 1);
1234         }
1235         // 1D gradient texture
1236         for (x = 0;x < ATTEN1DSIZE;x++)
1237                 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1238         r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1239         Mem_Free(data);
1240
1241         R_Shadow_MakeTextures_MakeCorona();
1242
1243         // Editor light sprites
1244         r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1245         "................"
1246         ".3............3."
1247         "..5...2332...5.."
1248         "...7.3....3.7..."
1249         "....7......7...."
1250         "...3.7....7.3..."
1251         "..2...7..7...2.."
1252         "..3..........3.."
1253         "..3..........3.."
1254         "..2...7..7...2.."
1255         "...3.7....7.3..."
1256         "....7......7...."
1257         "...7.3....3.7..."
1258         "..5...2332...5.."
1259         ".3............3."
1260         "................"
1261         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1262         r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1263         "................"
1264         "................"
1265         "......1111......"
1266         "....11233211...."
1267         "...1234554321..."
1268         "...1356776531..."
1269         "..124677776421.."
1270         "..135777777531.."
1271         "..135777777531.."
1272         "..124677776421.."
1273         "...1356776531..."
1274         "...1234554321..."
1275         "....11233211...."
1276         "......1111......"
1277         "................"
1278         "................"
1279         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1280         r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1281         "................"
1282         "................"
1283         "......1111......"
1284         "....11233211...."
1285         "...1234554321..."
1286         "...1356226531..."
1287         "..12462..26421.."
1288         "..1352....2531.."
1289         "..1352....2531.."
1290         "..12462..26421.."
1291         "...1356226531..."
1292         "...1234554321..."
1293         "....11233211...."
1294         "......1111......"
1295         "................"
1296         "................"
1297         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1298         r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1299         "................"
1300         "................"
1301         "......2772......"
1302         "....27755772...."
1303         "..277533335772.."
1304         "..753333333357.."
1305         "..777533335777.."
1306         "..735775577537.."
1307         "..733357753337.."
1308         "..733337733337.."
1309         "..753337733357.."
1310         "..277537735772.."
1311         "....27777772...."
1312         "......2772......"
1313         "................"
1314         "................"
1315         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1316         r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1317         "................"
1318         "................"
1319         "......2772......"
1320         "....27722772...."
1321         "..2772....2772.."
1322         "..72........27.."
1323         "..7772....2777.."
1324         "..7.27722772.7.."
1325         "..7...2772...7.."
1326         "..7....77....7.."
1327         "..72...77...27.."
1328         "..2772.77.2772.."
1329         "....27777772...."
1330         "......2772......"
1331         "................"
1332         "................"
1333         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1334         r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1335         "................"
1336         ".777752..257777."
1337         ".742........247."
1338         ".72..........27."
1339         ".7............7."
1340         ".5............5."
1341         ".2............2."
1342         "................"
1343         "................"
1344         ".2............2."
1345         ".5............5."
1346         ".7............7."
1347         ".72..........27."
1348         ".742........247."
1349         ".777752..257777."
1350         "................"
1351         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1352 }
1353
1354 void R_Shadow_RenderMode_Begin(void)
1355 {
1356 #if 0
1357         GLint drawbuffer;
1358         GLint readbuffer;
1359 #endif
1360
1361         if (r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1362          || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1363                 R_Shadow_MakeTextures();
1364
1365         CHECKGLERROR
1366         R_Mesh_ResetTextureState();
1367         GL_BlendFunc(GL_ONE, GL_ZERO);
1368         GL_DepthRange(0, 1);
1369         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1370         GL_DepthTest(true);
1371         GL_DepthMask(false);
1372         GL_Color(0, 0, 0, 1);
1373         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1374         
1375         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1376         r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1377
1378         CHECKGLERROR
1379 #if 0
1380         qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
1381         qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
1382         r_shadow_drawbuffer = drawbuffer;
1383         r_shadow_readbuffer = readbuffer;
1384 #endif
1385         r_shadow_cullface_front = r_refdef.view.cullface_front;
1386         r_shadow_cullface_back = r_refdef.view.cullface_back;
1387 }
1388
1389 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
1390 {
1391         rsurface.rtlight = rtlight;
1392 }
1393
1394 void R_Shadow_RenderMode_Reset(void)
1395 {
1396         R_Mesh_ResetTextureState();
1397         R_Mesh_SetRenderTargets(r_shadow_viewfbo, r_shadow_viewdepthtexture, r_shadow_viewcolortexture, NULL, NULL, NULL);
1398         R_SetViewport(&r_refdef.view.viewport);
1399         GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
1400         GL_DepthRange(0, 1);
1401         GL_DepthTest(true);
1402         GL_DepthMask(false);
1403         GL_DepthFunc(GL_LEQUAL);
1404         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1405         r_refdef.view.cullface_front = r_shadow_cullface_front;
1406         r_refdef.view.cullface_back = r_shadow_cullface_back;
1407         GL_CullFace(r_refdef.view.cullface_back);
1408         GL_Color(1, 1, 1, 1);
1409         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
1410         GL_BlendFunc(GL_ONE, GL_ZERO);
1411         R_SetupShader_Generic_NoTexture(false, false);
1412         r_shadow_usingshadowmap2d = false;
1413 }
1414
1415 void R_Shadow_ClearStencil(void)
1416 {
1417         GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 0);
1418         r_refdef.stats[r_stat_lights_clears]++;
1419 }
1420
1421 static void R_Shadow_MakeVSDCT(void)
1422 {
1423         // maps to a 2x3 texture rectangle with normalized coordinates
1424         // +-
1425         // XX
1426         // YY
1427         // ZZ
1428         // stores abs(dir.xy), offset.xy/2.5
1429         unsigned char data[4*6] =
1430         {
1431                 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
1432                 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
1433                 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
1434                 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
1435                 0,   0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
1436                 0,   0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
1437         };
1438         r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
1439 }
1440
1441 static void R_Shadow_MakeShadowMap(int texturesize)
1442 {
1443         switch (r_shadow_shadowmode)
1444         {
1445         case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
1446                 if (r_shadow_shadowmap2ddepthtexture) return;
1447                 if (r_fb.usedepthtextures)
1448                 {
1449                         r_shadow_shadowmap2ddepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", texturesize, texturesize, r_shadow_shadowmapdepthbits >= 24 ? (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP24_COMP : TEXTYPE_SHADOWMAP24_RAW) : (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP16_COMP : TEXTYPE_SHADOWMAP16_RAW), r_shadow_shadowmapsampler);
1450                         r_shadow_shadowmap2ddepthbuffer = NULL;
1451                         r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
1452                 }
1453                 else
1454                 {
1455                         r_shadow_shadowmap2ddepthtexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", texturesize, texturesize, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
1456                         r_shadow_shadowmap2ddepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "shadowmap", texturesize, texturesize, r_shadow_shadowmapdepthbits >= 24 ? TEXTYPE_DEPTHBUFFER24 : TEXTYPE_DEPTHBUFFER16);
1457                         r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
1458                 }
1459                 break;
1460         default:
1461                 return;
1462         }
1463 }
1464
1465 void R_Shadow_ClearShadowMapTexture(void)
1466 {
1467         r_viewport_t viewport;
1468         float clearcolor[4];
1469
1470         // if they don't exist, create our textures now
1471         if (!r_shadow_shadowmap2ddepthtexture)
1472                 R_Shadow_MakeShadowMap(r_shadow_shadowmaptexturesize);
1473         if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
1474                 R_Shadow_MakeVSDCT();
1475
1476         // we're setting up to render shadowmaps, so change rendermode
1477         r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
1478
1479         R_Mesh_ResetTextureState();
1480         R_Shadow_RenderMode_Reset();
1481         if (r_shadow_shadowmap2ddepthbuffer)
1482                 R_Mesh_SetRenderTargets(r_shadow_fbo2d, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
1483         else
1484                 R_Mesh_SetRenderTargets(r_shadow_fbo2d, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
1485         R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL, false); // FIXME test if we have a skeletal model?
1486         GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
1487         GL_DepthMask(true);
1488         GL_DepthTest(true);
1489
1490         // we have to set a viewport to clear anything in some renderpaths (D3D)
1491         R_Viewport_InitOrtho(&viewport, &identitymatrix, 0, 0, r_shadow_shadowmaptexturesize, r_shadow_shadowmaptexturesize, 0, 0, 1.0, 1.0, 0.001f, 1.0f, NULL);
1492         R_SetViewport(&viewport);
1493         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
1494         if (r_shadow_shadowmap2ddepthbuffer)
1495                 GL_ColorMask(1, 1, 1, 1);
1496         else
1497                 GL_ColorMask(0, 0, 0, 0);
1498         switch (vid.renderpath)
1499         {
1500         case RENDERPATH_GL32:
1501         case RENDERPATH_GLES2:
1502                 GL_CullFace(r_refdef.view.cullface_back);
1503                 break;
1504         }
1505         Vector4Set(clearcolor, 1, 1, 1, 1);
1506         if (r_shadow_shadowmap2ddepthbuffer)
1507                 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
1508         else
1509                 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
1510 }
1511
1512 static void R_Shadow_SetShadowmapParametersForLight(qboolean noselfshadowpass)
1513 {
1514         int size = rsurface.rtlight->shadowmapatlassidesize;
1515         float nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
1516         float farclip = 1.0f;
1517         float bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
1518         r_shadow_lightshadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2ddepthtexture);
1519         r_shadow_lightshadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2ddepthtexture);
1520         r_shadow_lightshadowmap_texturescale[2] = rsurface.rtlight->shadowmapatlasposition[0] + (noselfshadowpass ? size * 2 : 0);
1521         r_shadow_lightshadowmap_texturescale[3] = rsurface.rtlight->shadowmapatlasposition[1];
1522         r_shadow_lightshadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
1523         r_shadow_lightshadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
1524         r_shadow_lightshadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
1525         r_shadow_lightshadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
1526         if (r_shadow_shadowmap2ddepthbuffer)
1527         {
1528                 // completely different meaning than in depthtexture approach
1529                 r_shadow_lightshadowmap_parameters[1] = 0;
1530                 r_shadow_lightshadowmap_parameters[3] = -bias;
1531         }
1532 }
1533
1534 static void R_Shadow_RenderMode_ShadowMap(int side, int size, int x, int y)
1535 {
1536         float nearclip, farclip, bias;
1537         r_viewport_t viewport;
1538         int flipped;
1539
1540         if (r_shadow_rendermode != R_SHADOW_RENDERMODE_SHADOWMAP2D)
1541         {
1542                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
1543
1544                 R_Mesh_ResetTextureState();
1545                 R_Shadow_RenderMode_Reset();
1546                 if (r_shadow_shadowmap2ddepthbuffer)
1547                         R_Mesh_SetRenderTargets(r_shadow_fbo2d, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
1548                 else
1549                         R_Mesh_SetRenderTargets(r_shadow_fbo2d, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
1550                 R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL, false); // FIXME test if we have a skeletal model?
1551                 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
1552                 GL_DepthMask(true);
1553                 GL_DepthTest(true);
1554         }
1555
1556         nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
1557         farclip = 1.0f;
1558         bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
1559
1560         R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL, x, y);
1561         R_SetViewport(&viewport);
1562         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
1563         flipped = (side & 1) ^ (side >> 2);
1564         r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
1565         r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
1566
1567         if (r_shadow_shadowmap2ddepthbuffer)
1568                 GL_ColorMask(1,1,1,1);
1569         else
1570                 GL_ColorMask(0,0,0,0);
1571         switch(vid.renderpath)
1572         {
1573         case RENDERPATH_GL32:
1574         case RENDERPATH_GLES2:
1575                 GL_CullFace(r_refdef.view.cullface_back);
1576                 break;
1577         }
1578
1579         // used in R_Q1BSP_DrawShadowMap code to check surfacesides[]
1580         r_shadow_shadowmapside = side;
1581 }
1582
1583 void R_Shadow_RenderMode_Lighting(qboolean transparent, qboolean shadowmapping, qboolean noselfshadowpass)
1584 {
1585         R_Mesh_ResetTextureState();
1586         if (transparent)
1587         {
1588                 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
1589                 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
1590                 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
1591                 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
1592         }
1593         if (shadowmapping)
1594                 R_Shadow_SetShadowmapParametersForLight(noselfshadowpass);
1595         R_Shadow_RenderMode_Reset();
1596         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1597         if (!transparent)
1598                 GL_DepthFunc(GL_EQUAL);
1599         // do global setup needed for the chosen lighting mode
1600         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
1601                 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
1602         r_shadow_usingshadowmap2d = shadowmapping;
1603         r_shadow_rendermode = r_shadow_lightingrendermode;
1604 }
1605
1606 static const unsigned short bboxelements[36] =
1607 {
1608         5, 1, 3, 5, 3, 7,
1609         6, 2, 0, 6, 0, 4,
1610         7, 3, 2, 7, 2, 6,
1611         4, 0, 1, 4, 1, 5,
1612         4, 5, 7, 4, 7, 6,
1613         1, 0, 2, 1, 2, 3,
1614 };
1615
1616 static const float bboxpoints[8][3] =
1617 {
1618         {-1,-1,-1},
1619         { 1,-1,-1},
1620         {-1, 1,-1},
1621         { 1, 1,-1},
1622         {-1,-1, 1},
1623         { 1,-1, 1},
1624         {-1, 1, 1},
1625         { 1, 1, 1},
1626 };
1627
1628 void R_Shadow_RenderMode_DrawDeferredLight(qboolean shadowmapping)
1629 {
1630         int i;
1631         float vertex3f[8*3];
1632         const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
1633 // do global setup needed for the chosen lighting mode
1634         R_Shadow_RenderMode_Reset();
1635         r_shadow_rendermode = r_shadow_lightingrendermode;
1636         R_EntityMatrix(&identitymatrix);
1637         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1638         if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
1639                 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
1640         else
1641                 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
1642
1643         r_shadow_usingshadowmap2d = shadowmapping;
1644
1645         // render the lighting
1646         R_SetupShader_DeferredLight(rsurface.rtlight);
1647         for (i = 0;i < 8;i++)
1648                 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
1649         GL_ColorMask(1,1,1,1);
1650         GL_DepthMask(false);
1651         GL_DepthRange(0, 1);
1652         GL_PolygonOffset(0, 0);
1653         GL_DepthTest(true);
1654         GL_DepthFunc(GL_GREATER);
1655         GL_CullFace(r_refdef.view.cullface_back);
1656         R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL, 0);
1657         R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
1658 }
1659
1660 static qboolean R_Shadow_BounceGrid_CheckEnable(int flag)
1661 {
1662         qboolean enable = r_shadow_bouncegrid_state.capable && r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
1663         int lightindex;
1664         int range;
1665         dlight_t *light;
1666         rtlight_t *rtlight;
1667         vec3_t lightcolor;
1668
1669         // see if there are really any lights to render...
1670         if (enable && r_shadow_bouncegrid_static.integer)
1671         {
1672                 enable = false;
1673                 range = (unsigned int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
1674                 for (lightindex = 0;lightindex < range;lightindex++)
1675                 {
1676                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
1677                         if (!light || !(light->flags & flag))
1678                                 continue;
1679                         rtlight = &light->rtlight;
1680                         // when static, we skip styled lights because they tend to change...
1681                         if (rtlight->style > 0)
1682                                 continue;
1683                         VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
1684                         if (!VectorLength2(lightcolor))
1685                                 continue;
1686                         enable = true;
1687                         break;
1688                 }
1689         }
1690
1691         return enable;
1692 }
1693
1694 static void R_Shadow_BounceGrid_GenerateSettings(r_shadow_bouncegrid_settings_t *settings)
1695 {
1696         qboolean s = r_shadow_bouncegrid_static.integer != 0;
1697         float spacing = bound(1.0f, s ? r_shadow_bouncegrid_static_spacing.value : r_shadow_bouncegrid_dynamic_spacing.value, 1024.0f);
1698         float quality = bound(0.0001f, (s ? r_shadow_bouncegrid_static_quality.value : r_shadow_bouncegrid_dynamic_quality.value), 1024.0f);
1699         float bounceminimumintensity = s ? r_shadow_bouncegrid_static_bounceminimumintensity.value : r_shadow_bouncegrid_dynamic_bounceminimumintensity.value;
1700
1701         // prevent any garbage in alignment padded areas as we'll be using memcmp
1702         memset(settings, 0, sizeof(*settings));
1703
1704         // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
1705         settings->staticmode                    = s;
1706         settings->blur                          = r_shadow_bouncegrid_blur.integer != 0;
1707         settings->floatcolors                   = bound(0, r_shadow_bouncegrid_floatcolors.integer, 2);
1708         settings->lightpathsize                 = bound(0.0f, r_shadow_bouncegrid_lightpathsize.value, 1024.0f);
1709         settings->directionalshading            = (s ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_dynamic_directionalshading.integer != 0) && r_shadow_bouncegrid_state.allowdirectionalshading;
1710         settings->dlightparticlemultiplier      = s ? 0 : r_shadow_bouncegrid_dynamic_dlightparticlemultiplier.value;
1711         settings->hitmodels                     = s ? false : r_shadow_bouncegrid_dynamic_hitmodels.integer != 0;
1712         settings->includedirectlighting         = r_shadow_bouncegrid_includedirectlighting.integer != 0 || r_shadow_bouncegrid.integer == 2;
1713         settings->lightradiusscale              = (s ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_dynamic_lightradiusscale.value);
1714         settings->maxbounce                     = (s ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_dynamic_maxbounce.integer);
1715         settings->particlebounceintensity       = r_shadow_bouncegrid_particlebounceintensity.value;
1716         settings->particleintensity             = r_shadow_bouncegrid_particleintensity.value * (settings->directionalshading ? 4.0f : 1.0f) / 65536.0f;
1717         settings->maxphotons                    = s ? r_shadow_bouncegrid_static_maxphotons.integer : r_shadow_bouncegrid_dynamic_maxphotons.integer;
1718         settings->energyperphoton               = 4096.0f / quality;
1719         settings->spacing[0]                    = spacing;
1720         settings->spacing[1]                    = spacing;
1721         settings->spacing[2]                    = spacing;
1722         settings->rng_type                      = r_shadow_bouncegrid_rng_type.integer;
1723         settings->rng_seed                      = r_shadow_bouncegrid_rng_seed.integer;
1724         settings->bounceminimumintensity2       = bounceminimumintensity * bounceminimumintensity;
1725         settings->normalizevectors              = r_shadow_bouncegrid_normalizevectors.integer != 0;
1726         settings->subsamples                    = bound(1, r_shadow_bouncegrid_subsamples.integer, 4);
1727
1728         // bound the values for sanity
1729         settings->maxphotons = bound(1, settings->maxphotons, 25000000);
1730         settings->lightradiusscale = bound(0.0001f, settings->lightradiusscale, 1024.0f);
1731         settings->maxbounce = bound(0, settings->maxbounce, 16);
1732         settings->spacing[0] = bound(1, settings->spacing[0], 512);
1733         settings->spacing[1] = bound(1, settings->spacing[1], 512);
1734         settings->spacing[2] = bound(1, settings->spacing[2], 512);
1735 }
1736
1737 static void R_Shadow_BounceGrid_UpdateSpacing(void)
1738 {
1739         float m[16];
1740         int c[4];
1741         int resolution[3];
1742         int numpixels;
1743         vec3_t ispacing;
1744         vec3_t maxs;
1745         vec3_t mins;
1746         vec3_t size;
1747         vec3_t spacing;
1748         r_shadow_bouncegrid_settings_t *settings = &r_shadow_bouncegrid_state.settings;
1749
1750         // get the spacing values
1751         spacing[0] = settings->spacing[0];
1752         spacing[1] = settings->spacing[1];
1753         spacing[2] = settings->spacing[2];
1754         ispacing[0] = 1.0f / spacing[0];
1755         ispacing[1] = 1.0f / spacing[1];
1756         ispacing[2] = 1.0f / spacing[2];
1757
1758         // calculate texture size enclosing entire world bounds at the spacing
1759         if (r_refdef.scene.worldmodel)
1760         {
1761                 int lightindex;
1762                 int range;
1763                 qboolean bounds_set = false;
1764                 dlight_t *light;
1765                 rtlight_t *rtlight;
1766
1767                 // calculate bounds enclosing world lights as they should be noticably tighter 
1768                 // than the world bounds on maps with unlit monster containers (see e1m7 etc)
1769                 range = (unsigned int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
1770                 for (lightindex = 0;lightindex < range;lightindex++)
1771                 {
1772                         const vec_t *rtlmins, *rtlmaxs;
1773
1774                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
1775                         if (!light)
1776                                 continue;
1777
1778                         rtlight = &light->rtlight;
1779                         rtlmins = rtlight->cullmins;
1780                         rtlmaxs = rtlight->cullmaxs;
1781
1782                         if (!bounds_set)
1783                         {
1784                                 VectorCopy(rtlmins, mins);
1785                                 VectorCopy(rtlmaxs, maxs);
1786                                 bounds_set = true;
1787                         }
1788                         else
1789                         {
1790                                 mins[0] = min(mins[0], rtlmins[0]);
1791                                 mins[1] = min(mins[1], rtlmins[1]);
1792                                 mins[2] = min(mins[2], rtlmins[2]);
1793                                 maxs[0] = max(maxs[0], rtlmaxs[0]);
1794                                 maxs[1] = max(maxs[1], rtlmaxs[1]);
1795                                 maxs[2] = max(maxs[2], rtlmaxs[2]);
1796                         }
1797                 }
1798
1799                 // limit to no larger than the world bounds
1800                 mins[0] = max(mins[0], r_refdef.scene.worldmodel->normalmins[0]);
1801                 mins[1] = max(mins[1], r_refdef.scene.worldmodel->normalmins[1]);
1802                 mins[2] = max(mins[2], r_refdef.scene.worldmodel->normalmins[2]);
1803                 maxs[0] = min(maxs[0], r_refdef.scene.worldmodel->normalmaxs[0]);
1804                 maxs[1] = min(maxs[1], r_refdef.scene.worldmodel->normalmaxs[1]);
1805                 maxs[2] = min(maxs[2], r_refdef.scene.worldmodel->normalmaxs[2]);
1806
1807                 VectorMA(mins, -2.0f, spacing, mins);
1808                 VectorMA(maxs, 2.0f, spacing, maxs);
1809         }
1810         else
1811         {
1812                 VectorSet(mins, -1048576.0f, -1048576.0f, -1048576.0f);
1813                 VectorSet(maxs,  1048576.0f,  1048576.0f,  1048576.0f);
1814         }
1815         VectorSubtract(maxs, mins, size);
1816         // now we can calculate the resolution we want
1817         c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
1818         c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
1819         c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
1820         // figure out the exact texture size (honoring power of 2 if required)
1821         resolution[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
1822         resolution[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
1823         resolution[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
1824         size[0] = spacing[0] * resolution[0];
1825         size[1] = spacing[1] * resolution[1];
1826         size[2] = spacing[2] * resolution[2];
1827
1828         // if dynamic we may or may not want to use the world bounds
1829         // if the dynamic size is smaller than the world bounds, use it instead
1830         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]))
1831         {
1832                 // we know the resolution we want
1833                 c[0] = r_shadow_bouncegrid_dynamic_x.integer;
1834                 c[1] = r_shadow_bouncegrid_dynamic_y.integer;
1835                 c[2] = r_shadow_bouncegrid_dynamic_z.integer;
1836                 // now we can calculate the texture size
1837                 resolution[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
1838                 resolution[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
1839                 resolution[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
1840                 size[0] = spacing[0] * resolution[0];
1841                 size[1] = spacing[1] * resolution[1];
1842                 size[2] = spacing[2] * resolution[2];
1843                 // center the rendering on the view
1844                 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
1845                 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
1846                 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
1847         }
1848
1849         // recalculate the maxs in case the resolution was not satisfactory
1850         VectorAdd(mins, size, maxs);
1851
1852         // check if this changed the texture size
1853         r_shadow_bouncegrid_state.createtexture = !(r_shadow_bouncegrid_state.texture && r_shadow_bouncegrid_state.resolution[0] == resolution[0] && r_shadow_bouncegrid_state.resolution[1] == resolution[1] && r_shadow_bouncegrid_state.resolution[2] == resolution[2] && r_shadow_bouncegrid_state.directional == r_shadow_bouncegrid_state.settings.directionalshading);
1854         r_shadow_bouncegrid_state.directional = r_shadow_bouncegrid_state.settings.directionalshading;
1855         VectorCopy(mins, r_shadow_bouncegrid_state.mins);
1856         VectorCopy(maxs, r_shadow_bouncegrid_state.maxs);
1857         VectorCopy(size, r_shadow_bouncegrid_state.size);
1858         VectorCopy(spacing, r_shadow_bouncegrid_state.spacing);
1859         VectorCopy(ispacing, r_shadow_bouncegrid_state.ispacing);
1860         VectorCopy(resolution, r_shadow_bouncegrid_state.resolution);
1861
1862         // reallocate pixels for this update if needed...
1863         r_shadow_bouncegrid_state.pixelbands = settings->directionalshading ? 8 : 1;
1864         r_shadow_bouncegrid_state.pixelsperband = resolution[0]*resolution[1]*resolution[2];
1865         r_shadow_bouncegrid_state.bytesperband = r_shadow_bouncegrid_state.pixelsperband*4;
1866         numpixels = r_shadow_bouncegrid_state.pixelsperband*r_shadow_bouncegrid_state.pixelbands;
1867         if (r_shadow_bouncegrid_state.numpixels != numpixels)
1868         {
1869                 if (r_shadow_bouncegrid_state.texture) { R_FreeTexture(r_shadow_bouncegrid_state.texture);r_shadow_bouncegrid_state.texture = NULL; }
1870
1871                 r_shadow_bouncegrid_state.highpixels = NULL;
1872
1873                 if (r_shadow_bouncegrid_state.blurpixels[0]) { Mem_Free(r_shadow_bouncegrid_state.blurpixels[0]); r_shadow_bouncegrid_state.blurpixels[0] = NULL; }
1874                 if (r_shadow_bouncegrid_state.blurpixels[1]) { Mem_Free(r_shadow_bouncegrid_state.blurpixels[1]); r_shadow_bouncegrid_state.blurpixels[1] = NULL; }
1875                 if (r_shadow_bouncegrid_state.u8pixels) { Mem_Free(r_shadow_bouncegrid_state.u8pixels); r_shadow_bouncegrid_state.u8pixels = NULL; }
1876                 if (r_shadow_bouncegrid_state.fp16pixels) { Mem_Free(r_shadow_bouncegrid_state.fp16pixels); r_shadow_bouncegrid_state.fp16pixels = NULL; }
1877                 if (r_shadow_bouncegrid_state.photons) { Mem_Free(r_shadow_bouncegrid_state.photons); r_shadow_bouncegrid_state.photons = NULL; }
1878                 if (r_shadow_bouncegrid_state.photons_tasks) { Mem_Free(r_shadow_bouncegrid_state.photons_tasks); r_shadow_bouncegrid_state.photons_tasks = NULL; }
1879                 if (r_shadow_bouncegrid_state.slices_tasks) Mem_Free(r_shadow_bouncegrid_state.slices_tasks); r_shadow_bouncegrid_state.slices_tasks = NULL;
1880
1881                 r_shadow_bouncegrid_state.numpixels = numpixels;
1882         }
1883
1884         // update the bouncegrid matrix to put it in the world properly
1885         memset(m, 0, sizeof(m));
1886         m[0] = 1.0f / r_shadow_bouncegrid_state.size[0];
1887         m[3] = -r_shadow_bouncegrid_state.mins[0] * m[0];
1888         m[5] = 1.0f / r_shadow_bouncegrid_state.size[1];
1889         m[7] = -r_shadow_bouncegrid_state.mins[1] * m[5];
1890         m[10] = 1.0f / r_shadow_bouncegrid_state.size[2];
1891         m[11] = -r_shadow_bouncegrid_state.mins[2] * m[10];
1892         m[15] = 1.0f;
1893         Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegrid_state.matrix, m);
1894 }
1895
1896 static float R_Shadow_BounceGrid_RefractiveIndexAtPoint(vec3_t point)
1897 {
1898         // check material at shadoworigin to see what the initial refractive index should be
1899         int hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK;
1900         int skipsupercontentsmask = 0;
1901         int skipmaterialflagsmask = MATERIALFLAG_CUSTOMBLEND;
1902         trace_t trace = CL_TracePoint(point, r_shadow_bouncegrid_state.settings.staticmode ? MOVE_WORLDONLY : (r_shadow_bouncegrid_state.settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, true, false, NULL, true);
1903         if (trace.starttexture && (trace.starttexture->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER)))
1904                 return trace.starttexture->refractive_index;
1905         else if (trace.startsupercontents & SUPERCONTENTS_LIQUIDSMASK)
1906                 return 1.333f; // water
1907         else
1908                 return 1.0003f; // air
1909 }
1910
1911 // enumerate world rtlights and sum the overall amount of light in the world,
1912 // from that we can calculate a scaling factor to fairly distribute photons
1913 // to all the lights
1914 //
1915 // this modifies rtlight->photoncolor and rtlight->photons
1916 static void R_Shadow_BounceGrid_AssignPhotons_Task(taskqueue_task_t *t)
1917 {
1918         // get the range of light numbers we'll be looping over:
1919         // range = static lights
1920         // range1 = dynamic lights (optional)
1921         // range2 = range + range1
1922         unsigned int range = (unsigned int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
1923         unsigned int range1 = r_shadow_bouncegrid_state.settings.staticmode ? 0 : r_refdef.scene.numlights;
1924         unsigned int range2 = range + range1;
1925         int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
1926
1927         float normalphotonscaling;
1928         float photonscaling;
1929         float photonintensity;
1930         float photoncount = 0.0f;
1931         float lightintensity;
1932         float radius;
1933         float s;
1934         float w;
1935         vec3_t cullmins;
1936         vec3_t cullmaxs;
1937         unsigned int lightindex;
1938         dlight_t *light;
1939         rtlight_t *rtlight;
1940         int shootparticles;
1941         int shotparticles;
1942         float bounceminimumintensity2;
1943         float startrefractiveindex;
1944         unsigned int seed;
1945         randomseed_t randomseed;
1946         vec3_t baseshotcolor;
1947
1948         normalphotonscaling = 1.0f / max(0.0000001f, r_shadow_bouncegrid_state.settings.energyperphoton);
1949         for (lightindex = 0;lightindex < range2;lightindex++)
1950         {
1951                 if (lightindex < range)
1952                 {
1953                         light = (dlight_t *)Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
1954                         if (!light)
1955                                 continue;
1956                         rtlight = &light->rtlight;
1957                         VectorClear(rtlight->bouncegrid_photoncolor);
1958                         rtlight->bouncegrid_photons = 0;
1959                         rtlight->bouncegrid_hits = 0;
1960                         rtlight->bouncegrid_traces = 0;
1961                         rtlight->bouncegrid_effectiveradius = 0;
1962                         if (!(light->flags & flag))
1963                                 continue;
1964                         if (r_shadow_bouncegrid_state.settings.staticmode)
1965                         {
1966                                 // when static, we skip styled lights because they tend to change...
1967                                 if (rtlight->style > 0 && r_shadow_bouncegrid.integer != 2)
1968                                         continue;
1969                         }
1970                         else if (r_shadow_debuglight.integer >= 0 && (int)lightindex != r_shadow_debuglight.integer)
1971                                 continue;
1972                 }
1973                 else
1974                 {
1975                         rtlight = r_refdef.scene.lights[lightindex - range];
1976                         VectorClear(rtlight->bouncegrid_photoncolor);
1977                         rtlight->bouncegrid_photons = 0;
1978                         rtlight->bouncegrid_hits = 0;
1979                         rtlight->bouncegrid_traces = 0;
1980                         rtlight->bouncegrid_effectiveradius = 0;
1981                 }
1982                 // draw only visible lights (major speedup)
1983                 radius = rtlight->radius * r_shadow_bouncegrid_state.settings.lightradiusscale;
1984                 cullmins[0] = rtlight->shadoworigin[0] - radius;
1985                 cullmins[1] = rtlight->shadoworigin[1] - radius;
1986                 cullmins[2] = rtlight->shadoworigin[2] - radius;
1987                 cullmaxs[0] = rtlight->shadoworigin[0] + radius;
1988                 cullmaxs[1] = rtlight->shadoworigin[1] + radius;
1989                 cullmaxs[2] = rtlight->shadoworigin[2] + radius;
1990                 w = r_shadow_lightintensityscale.value * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
1991                 if (!r_shadow_bouncegrid_state.settings.staticmode)
1992                 {
1993                         // skip if the expanded light box does not touch any visible leafs
1994                         if (r_refdef.scene.worldmodel
1995                                 && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
1996                                 && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
1997                                 continue;
1998                         // skip if the expanded light box is not visible to traceline
1999                         // note that PrepareLight already did this check but for a smaller box, so we
2000                         // end up casting more traces per frame per light when using bouncegrid, which
2001                         // is probably fine (and they use the same timer)
2002                         if (r_shadow_culllights_trace.integer)
2003                         {
2004                                 if (rtlight->trace_timer != realtime && R_CanSeeBox(rtlight->trace_timer == 0 ? r_shadow_culllights_trace_tempsamples.integer : r_shadow_culllights_trace_samples.integer, r_shadow_culllights_trace_eyejitter.value, r_shadow_culllights_trace_enlarge.value, r_shadow_culllights_trace_expand.value, r_shadow_culllights_trace_pad.value, r_refdef.view.origin, rtlight->cullmins, rtlight->cullmaxs))
2005                                         rtlight->trace_timer = realtime;
2006                                 if (realtime - rtlight->trace_timer > r_shadow_culllights_trace_delay.value)
2007                                         continue;
2008                         }
2009                         // skip if expanded light box is offscreen
2010                         if (R_CullBox(cullmins, cullmaxs))
2011                                 continue;
2012                         // skip if overall light intensity is zero
2013                         if (w * VectorLength2(rtlight->color) == 0.0f)
2014                                 continue;
2015                 }
2016                 // a light that does not emit any light before style is applied, can be
2017                 // skipped entirely (it may just be a corona)
2018                 if (rtlight->radius == 0.0f || VectorLength2(rtlight->color) == 0.0f)
2019                         continue;
2020                 w *= ((rtlight->style >= 0 && rtlight->style < MAX_LIGHTSTYLES) ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1);
2021                 VectorScale(rtlight->color, w, rtlight->bouncegrid_photoncolor);
2022                 // skip lights that will emit no photons
2023                 if (!VectorLength2(rtlight->bouncegrid_photoncolor))
2024                         continue;
2025                 // shoot particles from this light
2026                 // use a calculation for the number of particles that will not
2027                 // vary with lightstyle, otherwise we get randomized particle
2028                 // distribution, the seeded random is only consistent for a
2029                 // consistent number of particles on this light...
2030                 s = rtlight->radius;
2031                 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2032                 if (lightindex >= range)
2033                         lightintensity *= r_shadow_bouncegrid_state.settings.dlightparticlemultiplier;
2034                 rtlight->bouncegrid_photons = lightintensity * s * s * normalphotonscaling;
2035                 photoncount += rtlight->bouncegrid_photons;
2036                 VectorScale(rtlight->bouncegrid_photoncolor, r_shadow_bouncegrid_state.settings.particleintensity * r_shadow_bouncegrid_state.settings.energyperphoton, rtlight->bouncegrid_photoncolor);
2037                 // if the lightstyle happens to be off right now, we can skip actually
2038                 // firing the photons, but we did have to count them in the total.
2039                 //if (VectorLength2(rtlight->photoncolor) == 0.0f)
2040                 //      rtlight->bouncegrid_photons = 0;
2041         }
2042         // the user provided an energyperphoton value which we try to use
2043         // if that results in too many photons to shoot this frame, then we cap it
2044         // which causes photons to appear/disappear from frame to frame, so we don't
2045         // like doing that in the typical case
2046         photonscaling = 1.0f;
2047         photonintensity = 1.0f;
2048         if (photoncount > r_shadow_bouncegrid_state.settings.maxphotons)
2049         {
2050                 photonscaling = r_shadow_bouncegrid_state.settings.maxphotons / photoncount;
2051                 photonintensity = 1.0f / photonscaling;
2052         }
2053
2054         // modify the lights to reflect our computed scaling
2055         for (lightindex = 0; lightindex < range2; lightindex++)
2056         {
2057                 if (lightindex < range)
2058                 {
2059                         light = (dlight_t *)Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2060                         if (!light)
2061                                 continue;
2062                         rtlight = &light->rtlight;
2063                 }
2064                 else
2065                         rtlight = r_refdef.scene.lights[lightindex - range];
2066                 rtlight->bouncegrid_photons *= photonscaling;
2067                 VectorScale(rtlight->bouncegrid_photoncolor, photonintensity, rtlight->bouncegrid_photoncolor);
2068         }
2069
2070         // compute a seed for the unstable random modes
2071         Math_RandomSeed_FromInts(&randomseed, 0, 0, 0, realtime * 1000.0);
2072         seed = realtime * 1000.0;
2073
2074         for (lightindex = 0; lightindex < range2; lightindex++)
2075         {
2076                 if (lightindex < range)
2077                 {
2078                         light = (dlight_t *)Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2079                         if (!light)
2080                                 continue;
2081                         rtlight = &light->rtlight;
2082                 }
2083                 else
2084                         rtlight = r_refdef.scene.lights[lightindex - range];
2085                 // note that this code used to keep track of residual photons and
2086                 // distribute them evenly to achieve exactly a desired photon count,
2087                 // but that caused unwanted flickering in dynamic mode
2088                 shootparticles = (int)floor(rtlight->bouncegrid_photons);
2089                 // skip if we won't be shooting any photons
2090                 if (!shootparticles)
2091                         continue;
2092                 radius = rtlight->radius * r_shadow_bouncegrid_state.settings.lightradiusscale;
2093                 //s = settings.particleintensity / shootparticles;
2094                 //VectorScale(rtlight->bouncegrid_photoncolor, s, baseshotcolor);
2095                 VectorCopy(rtlight->bouncegrid_photoncolor, baseshotcolor);
2096                 if (VectorLength2(baseshotcolor) <= 0.0f)
2097                         continue;
2098                 r_refdef.stats[r_stat_bouncegrid_lights]++;
2099                 r_refdef.stats[r_stat_bouncegrid_particles] += shootparticles;
2100                 // we stop caring about bounces once the brightness goes below this fraction of the original intensity
2101                 bounceminimumintensity2 = VectorLength(baseshotcolor) * r_shadow_bouncegrid_state.settings.bounceminimumintensity2;
2102
2103                 // check material at shadoworigin to see what the initial refractive index should be
2104                 startrefractiveindex = R_Shadow_BounceGrid_RefractiveIndexAtPoint(rtlight->shadoworigin);
2105
2106                 // for seeded random we start the RNG with the position of the light
2107                 if (r_shadow_bouncegrid_state.settings.rng_seed >= 0)
2108                 {
2109                         union
2110                         {
2111                                 unsigned int i[4];
2112                                 float f[4];
2113                         }
2114                         u;
2115                         u.f[0] = rtlight->shadoworigin[0];
2116                         u.f[1] = rtlight->shadoworigin[1];
2117                         u.f[2] = rtlight->shadoworigin[2];
2118                         u.f[3] = 1;
2119                         switch (r_shadow_bouncegrid_state.settings.rng_type)
2120                         {
2121                         default:
2122                         case 0:
2123                                 // we have to shift the seed provided by the user because the result must be odd
2124                                 Math_RandomSeed_FromInts(&randomseed, u.i[0], u.i[1], u.i[2], u.i[3] ^ (r_shadow_bouncegrid_state.settings.rng_seed << 1));
2125                                 break;
2126                         case 1:
2127                                 seed = u.i[0] ^ u.i[1] ^ u.i[2] ^ u.i[3] ^ r_shadow_bouncegrid_state.settings.rng_seed;
2128                                 break;
2129                         }
2130                 }
2131
2132                 for (shotparticles = 0; shotparticles < shootparticles && r_shadow_bouncegrid_state.numphotons < r_shadow_bouncegrid_state.settings.maxphotons; shotparticles++)
2133                 {
2134                         r_shadow_bouncegrid_photon_t *p = r_shadow_bouncegrid_state.photons + r_shadow_bouncegrid_state.numphotons++;
2135                         VectorCopy(baseshotcolor, p->color);
2136                         VectorCopy(rtlight->shadoworigin, p->start);
2137                         switch (r_shadow_bouncegrid_state.settings.rng_type)
2138                         {
2139                         default:
2140                         case 0:
2141                                 // figure out a random direction for the initial photon to go
2142                                 VectorLehmerRandom(&randomseed, p->end);
2143                                 break;
2144                         case 1:
2145                                 // figure out a random direction for the initial photon to go
2146                                 VectorCheeseRandom(seed, p->end);
2147                                 break;
2148                         }
2149
2150                         // we want a uniform distribution spherically, not merely within the sphere
2151                         if (r_shadow_bouncegrid_state.settings.normalizevectors)
2152                                 VectorNormalize(p->end);
2153
2154                         VectorMA(p->start, radius, p->end, p->end);
2155                         p->bounceminimumintensity2 = bounceminimumintensity2;
2156                         p->startrefractiveindex = startrefractiveindex;
2157                         p->numpaths = 0;
2158                 }
2159         }
2160
2161         t->done = 1;
2162 }
2163
2164 static void R_Shadow_BounceGrid_Slice(int zi)
2165 {
2166         float *highpixels = r_shadow_bouncegrid_state.highpixels;
2167         int xi, yi; // pixel increments
2168         float color[32] = { 0 };
2169         float radius = r_shadow_bouncegrid_state.settings.lightpathsize;
2170         float iradius = 1.0f / radius;
2171         int slicemins[3], slicemaxs[3];
2172         int resolution[3];
2173         int pixelsperband = r_shadow_bouncegrid_state.pixelsperband;
2174         int pixelbands = r_shadow_bouncegrid_state.pixelbands;
2175         int photonindex;
2176         int samples = r_shadow_bouncegrid_state.settings.subsamples;
2177         float isamples = 1.0f / samples;
2178         float samplescolorscale = isamples * isamples * isamples;
2179
2180         // we use these a lot, so get a local copy
2181         VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
2182
2183         for (photonindex = 0; photonindex < r_shadow_bouncegrid_state.numphotons; photonindex++)
2184         {
2185                 r_shadow_bouncegrid_photon_t *photon = r_shadow_bouncegrid_state.photons + photonindex;
2186                 int pathindex;
2187                 for (pathindex = 0; pathindex < photon->numpaths; pathindex++)
2188                 {
2189                         r_shadow_bouncegrid_photon_path_t *path = photon->paths + pathindex;
2190                         float pathstart[3], pathend[3], pathmins[3], pathmaxs[3], pathdelta[3], pathdir[3], pathlength2, pathilength;
2191
2192                         VectorSubtract(path->start, r_shadow_bouncegrid_state.mins, pathstart);
2193                         VectorSubtract(path->end, r_shadow_bouncegrid_state.mins, pathend);
2194
2195                         pathmins[2] = min(pathstart[2], pathend[2]);
2196                         slicemins[2] = (int)floor((pathmins[2] - radius) * r_shadow_bouncegrid_state.ispacing[2]);
2197                         pathmaxs[2] = max(pathstart[2], pathend[2]);
2198                         slicemaxs[2] = (int)floor((pathmaxs[2] + radius) * r_shadow_bouncegrid_state.ispacing[2] + 1);
2199
2200                         // skip if the path doesn't touch this slice
2201                         if (zi < slicemins[2] || zi >= slicemaxs[2])
2202                                 continue;
2203
2204                         pathmins[0] = min(pathstart[0], pathend[0]);
2205                         slicemins[0] = (int)floor((pathmins[0] - radius) * r_shadow_bouncegrid_state.ispacing[0]);
2206                         slicemins[0] = max(slicemins[0], 1);
2207                         pathmaxs[0] = max(pathstart[0], pathend[0]);
2208                         slicemaxs[0] = (int)floor((pathmaxs[0] + radius) * r_shadow_bouncegrid_state.ispacing[0]);
2209                         slicemaxs[0] = min(slicemaxs[0], resolution[0] - 1);
2210
2211                         pathmins[1] = min(pathstart[1], pathend[1]);
2212                         slicemins[1] = (int)floor((pathmins[1] - radius) * r_shadow_bouncegrid_state.ispacing[1] + 1);
2213                         slicemins[1] = max(slicemins[1], 1);
2214                         pathmaxs[1] = max(pathstart[1], pathend[1]);
2215                         slicemaxs[1] = (int)floor((pathmaxs[1] + radius) * r_shadow_bouncegrid_state.ispacing[1] + 1);
2216                         slicemaxs[1] = min(slicemaxs[1], resolution[1] - 1);
2217
2218                         // skip if the path is out of bounds on X or Y
2219                         if (slicemins[0] >= slicemaxs[0] || slicemins[1] >= slicemaxs[1])
2220                                 continue;
2221
2222                         // calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2223                         // accumulate average shotcolor
2224                         VectorSubtract(pathend, pathstart, pathdelta);
2225                         pathlength2 = VectorLength2(pathdelta);
2226                         pathilength = pathlength2 > 0.0f ? 1.0f / sqrt(pathlength2) : 0.0f;
2227                         VectorScale(pathdelta, pathilength, pathdir);
2228                         // the color is scaled by the number of subsamples
2229                         color[0] = path->color[0] * samplescolorscale;
2230                         color[1] = path->color[1] * samplescolorscale;
2231                         color[2] = path->color[2] * samplescolorscale;
2232                         color[3] = 0.0f;
2233                         if (pixelbands > 1)
2234                         {
2235                                 // store bentnormal in case the shader has a use for it,
2236                                 // bentnormal is an intensity-weighted average of the directions,
2237                                 // and will be normalized on conversion to texture pixels.
2238                                 float intensity = VectorLength(color);
2239                                 color[4] = pathdir[0] * intensity;
2240                                 color[5] = pathdir[1] * intensity;
2241                                 color[6] = pathdir[2] * intensity;
2242                                 color[7] = intensity;
2243                                 // for each color component (R, G, B) calculate the amount that a
2244                                 // direction contributes
2245                                 color[8] = color[0] * max(0.0f, pathdir[0]);
2246                                 color[9] = color[0] * max(0.0f, pathdir[1]);
2247                                 color[10] = color[0] * max(0.0f, pathdir[2]);
2248                                 color[11] = 0.0f;
2249                                 color[12] = color[1] * max(0.0f, pathdir[0]);
2250                                 color[13] = color[1] * max(0.0f, pathdir[1]);
2251                                 color[14] = color[1] * max(0.0f, pathdir[2]);
2252                                 color[15] = 0.0f;
2253                                 color[16] = color[2] * max(0.0f, pathdir[0]);
2254                                 color[17] = color[2] * max(0.0f, pathdir[1]);
2255                                 color[18] = color[2] * max(0.0f, pathdir[2]);
2256                                 color[19] = 0.0f;
2257                                 // and do the same for negative directions
2258                                 color[20] = color[0] * max(0.0f, -pathdir[0]);
2259                                 color[21] = color[0] * max(0.0f, -pathdir[1]);
2260                                 color[22] = color[0] * max(0.0f, -pathdir[2]);
2261                                 color[23] = 0.0f;
2262                                 color[24] = color[1] * max(0.0f, -pathdir[0]);
2263                                 color[25] = color[1] * max(0.0f, -pathdir[1]);
2264                                 color[26] = color[1] * max(0.0f, -pathdir[2]);
2265                                 color[27] = 0.0f;
2266                                 color[28] = color[2] * max(0.0f, -pathdir[0]);
2267                                 color[29] = color[2] * max(0.0f, -pathdir[1]);
2268                                 color[30] = color[2] * max(0.0f, -pathdir[2]);
2269                                 color[31] = 0.0f;
2270                         }
2271
2272                         for (yi = slicemins[1]; yi < slicemaxs[1]; yi++)
2273                         {
2274                                 for (xi = slicemins[0]; xi < slicemaxs[0]; xi++)
2275                                 {
2276                                         float sample[3], diff[3], nearest[3], along, distance2;
2277                                         float *p = highpixels + 4 * ((zi * resolution[1] + yi) * resolution[0] + xi);
2278                                         int xs, ys, zs;
2279                                         // loop over the subsamples
2280                                         for (zs = 0; zs < samples; zs++)
2281                                         {
2282                                                 sample[2] = (zi + (zs + 0.5f) * isamples) * r_shadow_bouncegrid_state.spacing[2];
2283                                                 for (ys = 0; ys < samples; ys++)
2284                                                 {
2285                                                         sample[1] = (yi + (ys + 0.5f) * isamples) * r_shadow_bouncegrid_state.spacing[1];
2286                                                         for (xs = 0; xs < samples; xs++)
2287                                                         {
2288                                                                 sample[0] = (xi + (xs + 0.5f) * isamples) * r_shadow_bouncegrid_state.spacing[0];
2289
2290                                                                 // measure distance from subsample to line segment and see if it is within radius
2291                                                                 along = DotProduct(sample, pathdir) * pathilength;
2292                                                                 if (along <= 0)
2293                                                                         VectorCopy(pathstart, nearest);
2294                                                                 else if (along >= 1)
2295                                                                         VectorCopy(pathend, nearest);
2296                                                                 else
2297                                                                         VectorLerp(pathstart, along, pathend, nearest);
2298                                                                 VectorSubtract(sample, nearest, diff);
2299                                                                 VectorScale(diff, iradius, diff);
2300                                                                 distance2 = VectorLength2(diff);
2301                                                                 if (distance2 < 1.0f)
2302                                                                 {
2303                                                                         // contribute some color to this pixel, across all bands
2304                                                                         float w = 1.0f - sqrt(distance2);
2305                                                                         int band;
2306                                                                         w *= w;
2307                                                                         if (pixelbands > 1)
2308                                                                         {
2309                                                                                 // small optimization for alpha - only color[7] is non-zero, so skip the rest of the alpha elements.
2310                                                                                 p[pixelsperband * 4 + 3] += color[7] * w;
2311                                                                         }
2312                                                                         for (band = 0; band < pixelbands; band++)
2313                                                                         {
2314                                                                                 // add to the pixel color (RGB only - see above)
2315                                                                                 p[band * pixelsperband * 4 + 0] += color[band * 4 + 0] * w;
2316                                                                                 p[band * pixelsperband * 4 + 1] += color[band * 4 + 1] * w;
2317                                                                                 p[band * pixelsperband * 4 + 2] += color[band * 4 + 2] * w;
2318                                                                         }
2319                                                                 }
2320                                                         }
2321                                                 }
2322                                         }
2323                                 }
2324                         }
2325                 }
2326         }
2327 }
2328
2329 static void R_Shadow_BounceGrid_Slice_Task(taskqueue_task_t *t)
2330 {
2331         R_Shadow_BounceGrid_Slice((int)t->i[0]);
2332         t->done = 1;
2333 }
2334
2335 static void R_Shadow_BounceGrid_EnqueueSlices_Task(taskqueue_task_t *t)
2336 {
2337         int i, slices;
2338         // we need to wait for the texture clear to finish before we start adding light to it
2339         if (r_shadow_bouncegrid_state.cleartex_task.done == 0)
2340         {
2341                 TaskQueue_Yield(t);
2342                 return;
2343         }
2344         slices = r_shadow_bouncegrid_state.resolution[2] - 2;
2345         for (i = 0; i < slices; i++)
2346                 TaskQueue_Setup(r_shadow_bouncegrid_state.slices_tasks + i, NULL, R_Shadow_BounceGrid_Slice_Task, i + 1, 0, NULL, NULL);
2347         TaskQueue_Enqueue(slices, r_shadow_bouncegrid_state.slices_tasks);
2348         TaskQueue_Setup(&r_shadow_bouncegrid_state.slices_done_task, NULL, TaskQueue_Task_CheckTasksDone, slices, 0, r_shadow_bouncegrid_state.slices_tasks, 0);
2349         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.slices_done_task);
2350         t->done = 1;
2351 }
2352
2353 static void R_Shadow_BounceGrid_BlurPixelsInDirection(const float *inpixels, float *outpixels, int off)
2354 {
2355         const float *inpixel;
2356         float *outpixel;
2357         int pixelbands = r_shadow_bouncegrid_state.pixelbands;
2358         int pixelband;
2359         unsigned int index;
2360         unsigned int x, y, z;
2361         unsigned int resolution[3];
2362         VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
2363         for (pixelband = 0;pixelband < pixelbands;pixelband++)
2364         {
2365                 for (z = 1;z < resolution[2]-1;z++)
2366                 {
2367                         for (y = 1;y < resolution[1]-1;y++)
2368                         {
2369                                 x = 1;
2370                                 index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
2371                                 inpixel = inpixels + 4*index;
2372                                 outpixel = outpixels + 4*index;
2373                                 for (;x < resolution[0]-1;x++, inpixel += 4, outpixel += 4)
2374                                 {
2375                                         outpixel[0] = (inpixel[0] + inpixel[  off] + inpixel[0-off]) * (1.0f / 3.0);
2376                                         outpixel[1] = (inpixel[1] + inpixel[1+off] + inpixel[1-off]) * (1.0f / 3.0);
2377                                         outpixel[2] = (inpixel[2] + inpixel[2+off] + inpixel[2-off]) * (1.0f / 3.0);
2378                                         outpixel[3] = (inpixel[3] + inpixel[3+off] + inpixel[3-off]) * (1.0f / 3.0);
2379                                 }
2380                         }
2381                 }
2382         }
2383 }
2384
2385 static void R_Shadow_BounceGrid_BlurPixels_Task(taskqueue_task_t *t)
2386 {
2387         float *pixels[4];
2388         unsigned int resolution[3];
2389         if (r_shadow_bouncegrid_state.settings.blur)
2390         {
2391                 VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
2392
2393                 pixels[0] = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index];
2394                 pixels[1] = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index ^ 1];
2395                 pixels[2] = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index];
2396                 pixels[3] = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index ^ 1];
2397
2398                 // blur on X
2399                 R_Shadow_BounceGrid_BlurPixelsInDirection(pixels[0], pixels[1], 4);
2400                 // blur on Y
2401                 R_Shadow_BounceGrid_BlurPixelsInDirection(pixels[1], pixels[2], resolution[0] * 4);
2402                 // blur on Z
2403                 R_Shadow_BounceGrid_BlurPixelsInDirection(pixels[2], pixels[3], resolution[0] * resolution[1] * 4);
2404
2405                 // toggle the state, highpixels now points to pixels[3] result
2406                 r_shadow_bouncegrid_state.highpixels_index ^= 1;
2407                 r_shadow_bouncegrid_state.highpixels = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index];
2408         }
2409         t->done = 1;
2410 }
2411
2412 static void R_Shadow_BounceGrid_ConvertPixelsAndUpload(void)
2413 {
2414         int floatcolors = r_shadow_bouncegrid_state.settings.floatcolors;
2415         unsigned char *pixelsbgra8 = NULL;
2416         unsigned char *pixelbgra8;
2417         unsigned short *pixelsrgba16f = NULL;
2418         unsigned short *pixelrgba16f;
2419         float *pixelsrgba32f = NULL;
2420         float *highpixels = r_shadow_bouncegrid_state.highpixels;
2421         float *highpixel;
2422         float *bandpixel;
2423         unsigned int pixelsperband = r_shadow_bouncegrid_state.pixelsperband;
2424         unsigned int pixelbands = r_shadow_bouncegrid_state.pixelbands;
2425         unsigned int pixelband;
2426         unsigned int x, y, z;
2427         unsigned int index, bandindex;
2428         unsigned int resolution[3];
2429         int c[4];
2430         VectorCopy(r_shadow_bouncegrid_state.resolution, resolution);
2431
2432         if (r_shadow_bouncegrid_state.createtexture && r_shadow_bouncegrid_state.texture)
2433         {
2434                 R_FreeTexture(r_shadow_bouncegrid_state.texture);
2435                 r_shadow_bouncegrid_state.texture = NULL;
2436         }
2437
2438         // if bentnormals exist, we need to normalize and bias them for the shader
2439         if (pixelbands > 1)
2440         {
2441                 pixelband = 1;
2442                 for (z = 0;z < resolution[2]-1;z++)
2443                 {
2444                         for (y = 0;y < resolution[1]-1;y++)
2445                         {
2446                                 x = 1;
2447                                 index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
2448                                 highpixel = highpixels + 4*index;
2449                                 for (;x < resolution[0]-1;x++, index++, highpixel += 4)
2450                                 {
2451                                         // only convert pixels that were hit by photons
2452                                         if (highpixel[3] != 0.0f)
2453                                                 VectorNormalize(highpixel);
2454                                         VectorSet(highpixel, highpixel[0] * 0.5f + 0.5f, highpixel[1] * 0.5f + 0.5f, highpixel[2] * 0.5f + 0.5f);
2455                                         highpixel[pixelsperband * 4 + 3] = 1.0f;
2456                                 }
2457                         }
2458                 }
2459         }
2460
2461         // start by clearing the pixels array - we won't be writing to all of it
2462         //
2463         // then process only the pixels that have at least some color, skipping
2464         // the higher bands for speed on pixels that are black
2465         switch (floatcolors)
2466         {
2467         case 0:
2468                 if (r_shadow_bouncegrid_state.u8pixels == NULL)
2469                         r_shadow_bouncegrid_state.u8pixels = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(unsigned char[4]));
2470                 pixelsbgra8 = r_shadow_bouncegrid_state.u8pixels;
2471                 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2472                 {
2473                         if (pixelband == 1)
2474                                 memset(pixelsbgra8 + pixelband * r_shadow_bouncegrid_state.bytesperband, 128, r_shadow_bouncegrid_state.bytesperband);
2475                         else
2476                                 memset(pixelsbgra8 + pixelband * r_shadow_bouncegrid_state.bytesperband, 0, r_shadow_bouncegrid_state.bytesperband);
2477                 }
2478                 for (z = 1;z < resolution[2]-1;z++)
2479                 {
2480                         for (y = 1;y < resolution[1]-1;y++)
2481                         {
2482                                 x = 1;
2483                                 pixelband = 0;
2484                                 index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
2485                                 highpixel = highpixels + 4*index;
2486                                 for (;x < resolution[0]-1;x++, index++, highpixel += 4)
2487                                 {
2488                                         // only convert pixels that were hit by photons
2489                                         if (VectorLength2(highpixel))
2490                                         {
2491                                                 // normalize the bentnormal now
2492                                                 if (pixelbands > 1)
2493                                                 {
2494                                                         VectorNormalize(highpixel + pixelsperband * 4);
2495                                                         highpixel[pixelsperband * 4 + 3] = 1.0f;
2496                                                 }
2497                                                 // process all of the pixelbands for this pixel
2498                                                 for (pixelband = 0, bandindex = index;pixelband < pixelbands;pixelband++, bandindex += pixelsperband)
2499                                                 {
2500                                                         pixelbgra8 = pixelsbgra8 + 4*bandindex;
2501                                                         bandpixel = highpixels + 4*bandindex;
2502                                                         c[0] = (int)(bandpixel[0]*256.0f);
2503                                                         c[1] = (int)(bandpixel[1]*256.0f);
2504                                                         c[2] = (int)(bandpixel[2]*256.0f);
2505                                                         c[3] = (int)(bandpixel[3]*256.0f);
2506                                                         pixelbgra8[2] = (unsigned char)bound(0, c[0], 255);
2507                                                         pixelbgra8[1] = (unsigned char)bound(0, c[1], 255);
2508                                                         pixelbgra8[0] = (unsigned char)bound(0, c[2], 255);
2509                                                         pixelbgra8[3] = (unsigned char)bound(0, c[3], 255);
2510                                                 }
2511                                         }
2512                                 }
2513                         }
2514                 }
2515
2516                 if (!r_shadow_bouncegrid_state.createtexture)
2517                         R_UpdateTexture(r_shadow_bouncegrid_state.texture, pixelsbgra8, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2518                 else
2519                         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);
2520                 break;
2521         case 1:
2522                 if (r_shadow_bouncegrid_state.fp16pixels == NULL)
2523                         r_shadow_bouncegrid_state.fp16pixels = (unsigned short *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(unsigned short[4]));
2524                 pixelsrgba16f = r_shadow_bouncegrid_state.fp16pixels;
2525                 memset(pixelsrgba16f, 0, r_shadow_bouncegrid_state.numpixels * sizeof(unsigned short[4]));
2526                 for (z = 1;z < resolution[2]-1;z++)
2527                 {
2528                         for (y = 1;y < resolution[1]-1;y++)
2529                         {
2530                                 x = 1;
2531                                 pixelband = 0;
2532                                 index = ((pixelband*resolution[2]+z)*resolution[1]+y)*resolution[0]+x;
2533                                 highpixel = highpixels + 4*index;
2534                                 for (;x < resolution[0]-1;x++, index++, highpixel += 4)
2535                                 {
2536                                         // only convert pixels that were hit by photons
2537                                         if (VectorLength2(highpixel))
2538                                         {
2539                                                 // process all of the pixelbands for this pixel
2540                                                 for (pixelband = 0, bandindex = index;pixelband < pixelbands;pixelband++, bandindex += pixelsperband)
2541                                                 {
2542                                                         // time to have fun with IEEE 754 bit hacking...
2543                                                         union {
2544                                                                 float f[4];
2545                                                                 unsigned int raw[4];
2546                                                         } u;
2547                                                         pixelrgba16f = pixelsrgba16f + 4*bandindex;
2548                                                         bandpixel = highpixels + 4*bandindex;
2549                                                         VectorCopy4(bandpixel, u.f);
2550                                                         VectorCopy4(u.raw, c);
2551                                                         // this math supports negative numbers, snaps denormals to zero
2552                                                         //pixelrgba16f[0] = (unsigned short)(((c[0] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[0] - 0x38000000) >> 13) & 0x7FFF) | ((c[0] >> 16) & 0x8000));
2553                                                         //pixelrgba16f[1] = (unsigned short)(((c[1] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[1] - 0x38000000) >> 13) & 0x7FFF) | ((c[1] >> 16) & 0x8000));
2554                                                         //pixelrgba16f[2] = (unsigned short)(((c[2] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[2] - 0x38000000) >> 13) & 0x7FFF) | ((c[2] >> 16) & 0x8000));
2555                                                         //pixelrgba16f[3] = (unsigned short)(((c[3] & 0x7FFFFFFF) < 0x38000000) ? 0 : (((c[3] - 0x38000000) >> 13) & 0x7FFF) | ((c[3] >> 16) & 0x8000));
2556                                                         // this math does not support negative
2557                                                         pixelrgba16f[0] = (unsigned short)((c[0] < 0x38000000) ? 0 : ((c[0] - 0x38000000) >> 13));
2558                                                         pixelrgba16f[1] = (unsigned short)((c[1] < 0x38000000) ? 0 : ((c[1] - 0x38000000) >> 13));
2559                                                         pixelrgba16f[2] = (unsigned short)((c[2] < 0x38000000) ? 0 : ((c[2] - 0x38000000) >> 13));
2560                                                         pixelrgba16f[3] = (unsigned short)((c[3] < 0x38000000) ? 0 : ((c[3] - 0x38000000) >> 13));
2561                                                 }
2562                                         }
2563                                 }
2564                         }
2565                 }
2566
2567                 if (!r_shadow_bouncegrid_state.createtexture)
2568                         R_UpdateTexture(r_shadow_bouncegrid_state.texture, (const unsigned char *)pixelsrgba16f, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2569                 else
2570                         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);
2571                 break;
2572         case 2:
2573                 // our native format happens to match, so this is easy.
2574                 pixelsrgba32f = highpixels;
2575
2576                 if (!r_shadow_bouncegrid_state.createtexture)
2577                         R_UpdateTexture(r_shadow_bouncegrid_state.texture, (const unsigned char *)pixelsrgba32f, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2578                 else
2579                         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);
2580                 break;
2581         }
2582
2583         r_shadow_bouncegrid_state.lastupdatetime = realtime;
2584 }
2585
2586 void R_Shadow_BounceGrid_ClearTex_Task(taskqueue_task_t *t)
2587 {
2588         memset(r_shadow_bouncegrid_state.highpixels, 0, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
2589         t->done = 1;
2590 }
2591
2592 static void R_Shadow_BounceGrid_TracePhotons_Shot(r_shadow_bouncegrid_photon_t *p, int remainingbounces, vec3_t shotstart, vec3_t shotend, vec3_t shotcolor, float bounceminimumintensity2, float previousrefractiveindex)
2593 {
2594         int hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask;
2595         vec3_t shothit;
2596         vec3_t surfacenormal;
2597         vec3_t reflectstart, reflectend, reflectcolor;
2598         vec3_t refractstart, refractend, refractcolor;
2599         vec_t s;
2600         float reflectamount = 1.0f;
2601         trace_t cliptrace;
2602         // figure out what we want to interact with
2603         hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK;
2604         skipsupercontentsmask = 0;
2605         skipmaterialflagsmask = MATERIALFLAG_CUSTOMBLEND;
2606         //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2607         //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2608         if (r_shadow_bouncegrid_state.settings.staticmode || r_shadow_bouncegrid_state.settings.rng_seed < 0 || r_shadow_bouncegrid_threaded.integer)
2609         {
2610                 // static mode fires a LOT of rays but none of them are identical, so they are not cached
2611                 // non-stable random in dynamic mode also never reuses a direction, so there's no reason to cache it
2612                 cliptrace = CL_TraceLine(shotstart, shotend, r_shadow_bouncegrid_state.settings.staticmode ? MOVE_WORLDONLY : (r_shadow_bouncegrid_state.settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true, false, NULL, true, true);
2613         }
2614         else
2615         {
2616                 // dynamic mode fires many rays and most will match the cache from the previous frame
2617                 cliptrace = CL_Cache_TraceLineSurfaces(shotstart, shotend, r_shadow_bouncegrid_state.settings.staticmode ? MOVE_WORLDONLY : (r_shadow_bouncegrid_state.settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
2618         }
2619         VectorCopy(cliptrace.endpos, shothit);
2620         if ((remainingbounces == r_shadow_bouncegrid_state.settings.maxbounce || r_shadow_bouncegrid_state.settings.includedirectlighting) && p->numpaths < PHOTON_MAX_PATHS)
2621         {
2622                 qboolean notculled = true;
2623                 // cull paths that fail R_CullBox in dynamic mode
2624                 if (!r_shadow_bouncegrid_state.settings.staticmode
2625                         && r_shadow_bouncegrid_dynamic_culllightpaths.integer)
2626                 {
2627                         vec3_t cullmins, cullmaxs;
2628                         cullmins[0] = min(shotstart[0], shothit[0]) - r_shadow_bouncegrid_state.settings.spacing[0] - r_shadow_bouncegrid_state.settings.lightpathsize;
2629                         cullmins[1] = min(shotstart[1], shothit[1]) - r_shadow_bouncegrid_state.settings.spacing[1] - r_shadow_bouncegrid_state.settings.lightpathsize;
2630                         cullmins[2] = min(shotstart[2], shothit[2]) - r_shadow_bouncegrid_state.settings.spacing[2] - r_shadow_bouncegrid_state.settings.lightpathsize;
2631                         cullmaxs[0] = max(shotstart[0], shothit[0]) + r_shadow_bouncegrid_state.settings.spacing[0] + r_shadow_bouncegrid_state.settings.lightpathsize;
2632                         cullmaxs[1] = max(shotstart[1], shothit[1]) + r_shadow_bouncegrid_state.settings.spacing[1] + r_shadow_bouncegrid_state.settings.lightpathsize;
2633                         cullmaxs[2] = max(shotstart[2], shothit[2]) + r_shadow_bouncegrid_state.settings.spacing[2] + r_shadow_bouncegrid_state.settings.lightpathsize;
2634                         if (R_CullBox(cullmins, cullmaxs))
2635                                 notculled = false;
2636                 }
2637                 if (notculled)
2638                 {
2639                         r_shadow_bouncegrid_photon_path_t *path = p->paths + p->numpaths++;
2640                         VectorCopy(shotstart, path->start);
2641                         VectorCopy(shothit, path->end);
2642                         VectorCopy(shotcolor, path->color);
2643                 }
2644         }
2645         if (cliptrace.fraction < 1.0f && remainingbounces > 0)
2646         {
2647                 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2648                 // also clamp the resulting color to never add energy, even if the user requests extreme values
2649                 VectorCopy(cliptrace.plane.normal, surfacenormal);
2650                 VectorSet(reflectcolor, 0.5f, 0.5f, 0.5f);
2651                 VectorClear(refractcolor);
2652                 // FIXME: we need to determine the exact triangle, vertex color and texcoords and texture color and texture normal for the impacted point
2653                 if (cliptrace.hittexture)
2654                 {
2655                         if (cliptrace.hittexture->currentskinframe)
2656                                 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, reflectcolor);
2657                         if (cliptrace.hittexture->currentalpha < 1.0f && (cliptrace.hittexture->currentmaterialflags & (MATERIALFLAG_ALPHA | MATERIALFLAG_ALPHATEST)))
2658                         {
2659                                 reflectamount *= cliptrace.hittexture->currentalpha;
2660                                 if (cliptrace.hittexture->currentskinframe)
2661                                         reflectamount *= cliptrace.hittexture->currentskinframe->avgcolor[3];
2662                         }
2663                         if (cliptrace.hittexture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
2664                         {
2665                                 float Fresnel;
2666                                 vec3_t lightdir;
2667                                 //reflectchance = pow(min(1.0f, 1.0f - cliptrace.
2668                                 VectorSubtract(shotstart, shotend, lightdir);
2669                                 VectorNormalize(lightdir);
2670                                 Fresnel = min(1.0f, 1.0f - DotProduct(lightdir, surfacenormal));
2671                                 Fresnel = Fresnel * Fresnel * (cliptrace.hittexture->reflectmax - cliptrace.hittexture->reflectmin) + cliptrace.hittexture->reflectmin;
2672                                 reflectamount *= Fresnel;
2673                                 VectorCopy(cliptrace.hittexture->refractcolor4f, refractcolor);
2674                         }
2675                         if (cliptrace.hittexture->currentmaterialflags & MATERIALFLAG_REFRACTION)
2676                                 VectorCopy(cliptrace.hittexture->refractcolor4f, refractcolor);
2677                         // make sure we do not gain energy even if surface colors are out of bounds
2678                         reflectcolor[0] = min(reflectcolor[0], 1.0f);
2679                         reflectcolor[1] = min(reflectcolor[1], 1.0f);
2680                         reflectcolor[2] = min(reflectcolor[2], 1.0f);
2681                         refractcolor[0] = min(refractcolor[0], 1.0f);
2682                         refractcolor[1] = min(refractcolor[1], 1.0f);
2683                         refractcolor[2] = min(refractcolor[2], 1.0f);
2684                 }
2685                 // reflected and refracted shots
2686                 VectorScale(reflectcolor, r_shadow_bouncegrid_state.settings.particlebounceintensity * reflectamount, reflectcolor);
2687                 VectorScale(refractcolor, (1.0f - reflectamount), refractcolor);
2688                 VectorMultiply(reflectcolor, shotcolor, reflectcolor);
2689                 VectorMultiply(refractcolor, shotcolor, refractcolor);
2690
2691                 if (VectorLength2(reflectcolor) >= bounceminimumintensity2)
2692                 {
2693                         // reflect the remaining portion of the line across plane normal
2694                         VectorSubtract(shotend, shothit, reflectend);
2695                         VectorReflect(reflectend, 1.0, surfacenormal, reflectend);
2696                         // calculate the new line start and end
2697                         VectorCopy(shothit, reflectstart);
2698                         VectorAdd(reflectstart, reflectend, reflectend);
2699                         R_Shadow_BounceGrid_TracePhotons_Shot(p, remainingbounces - 1, reflectstart, reflectend, reflectcolor, bounceminimumintensity2, previousrefractiveindex);
2700                 }
2701
2702                 if (VectorLength2(refractcolor) >= bounceminimumintensity2)
2703                 {
2704                         // Check what refractive index is on the other side
2705                         float refractiveindex;
2706                         VectorMA(shothit, 0.0625f, cliptrace.plane.normal, refractstart);
2707                         refractiveindex = R_Shadow_BounceGrid_RefractiveIndexAtPoint(refractstart);
2708                         // reflect the remaining portion of the line across plane normal
2709                         VectorSubtract(shotend, shothit, refractend);
2710                         s = refractiveindex / previousrefractiveindex;
2711                         VectorReflect(refractend, -1.0f / s, surfacenormal, refractend);
2712                         // we also need to reflect the start to the other side of the plane so it doesn't just hit the same surface again
2713                         // calculate the new line start and end
2714                         VectorMA(shothit, 0.0625f, cliptrace.plane.normal, refractstart);
2715                         VectorAdd(refractstart, refractend, refractend);
2716                         R_Shadow_BounceGrid_TracePhotons_Shot(p, remainingbounces - 1, refractstart, refractend, refractcolor, bounceminimumintensity2, refractiveindex);
2717                 }
2718         }
2719 }
2720
2721 static void R_Shadow_BounceGrid_TracePhotons_ShotTask(taskqueue_task_t *t)
2722 {
2723         r_shadow_bouncegrid_photon_t *p = (r_shadow_bouncegrid_photon_t *)t->p[0];
2724         R_Shadow_BounceGrid_TracePhotons_Shot(p, r_shadow_bouncegrid_state.settings.maxbounce, p->start, p->end, p->color, p->bounceminimumintensity2, p->startrefractiveindex);
2725         t->done = 1;
2726 }
2727
2728 static void R_Shadow_BounceGrid_EnqueuePhotons_Task(taskqueue_task_t *t)
2729 {
2730         int i;
2731         for (i = 0; i < r_shadow_bouncegrid_state.numphotons; i++)
2732                 TaskQueue_Setup(r_shadow_bouncegrid_state.photons_tasks + i, NULL, R_Shadow_BounceGrid_TracePhotons_ShotTask, 0, 0, r_shadow_bouncegrid_state.photons + i, NULL);
2733         TaskQueue_Setup(&r_shadow_bouncegrid_state.photons_done_task, NULL, TaskQueue_Task_CheckTasksDone, r_shadow_bouncegrid_state.numphotons, 0, r_shadow_bouncegrid_state.photons_tasks, NULL);
2734         if (r_shadow_bouncegrid_threaded.integer)
2735         {
2736                 TaskQueue_Enqueue(r_shadow_bouncegrid_state.numphotons, r_shadow_bouncegrid_state.photons_tasks);
2737                 TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.photons_done_task);
2738         }
2739         else
2740         {
2741                 // when not threaded we still have to report task status
2742                 for (i = 0; i < r_shadow_bouncegrid_state.numphotons; i++)
2743                         r_shadow_bouncegrid_state.photons_tasks[i].func(r_shadow_bouncegrid_state.photons_tasks + i);
2744                 r_shadow_bouncegrid_state.photons_done_task.done = 1;
2745         }
2746         t->done = 1;
2747 }
2748
2749 void R_Shadow_UpdateBounceGridTexture(void)
2750 {
2751         int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2752         r_shadow_bouncegrid_settings_t settings;
2753         qboolean enable = false;
2754         qboolean settingschanged;
2755
2756         enable = R_Shadow_BounceGrid_CheckEnable(flag);
2757         
2758         R_Shadow_BounceGrid_GenerateSettings(&settings);
2759         
2760         // changing intensity does not require an update
2761         r_shadow_bouncegrid_state.intensity = r_shadow_bouncegrid_intensity.value;
2762
2763         settingschanged = memcmp(&r_shadow_bouncegrid_state.settings, &settings, sizeof(settings)) != 0;
2764
2765         // when settings change, we free everything as it is just simpler that way.
2766         if (settingschanged || !enable)
2767         {
2768                 // not enabled, make sure we free anything we don't need anymore.
2769                 if (r_shadow_bouncegrid_state.texture)
2770                 {
2771                         R_FreeTexture(r_shadow_bouncegrid_state.texture);
2772                         r_shadow_bouncegrid_state.texture = NULL;
2773                 }
2774                 r_shadow_bouncegrid_state.highpixels = NULL;
2775                 if (r_shadow_bouncegrid_state.blurpixels[0]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[0]); r_shadow_bouncegrid_state.blurpixels[0] = NULL;
2776                 if (r_shadow_bouncegrid_state.blurpixels[1]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[1]); r_shadow_bouncegrid_state.blurpixels[1] = NULL;
2777                 if (r_shadow_bouncegrid_state.u8pixels) Mem_Free(r_shadow_bouncegrid_state.u8pixels); r_shadow_bouncegrid_state.u8pixels = NULL;
2778                 if (r_shadow_bouncegrid_state.fp16pixels) Mem_Free(r_shadow_bouncegrid_state.fp16pixels); r_shadow_bouncegrid_state.fp16pixels = NULL;
2779                 if (r_shadow_bouncegrid_state.photons) Mem_Free(r_shadow_bouncegrid_state.photons); r_shadow_bouncegrid_state.photons = NULL;
2780                 if (r_shadow_bouncegrid_state.photons_tasks) Mem_Free(r_shadow_bouncegrid_state.photons_tasks); r_shadow_bouncegrid_state.photons_tasks = NULL;
2781                 if (r_shadow_bouncegrid_state.slices_tasks) Mem_Free(r_shadow_bouncegrid_state.slices_tasks); r_shadow_bouncegrid_state.slices_tasks = NULL;
2782                 r_shadow_bouncegrid_state.numpixels = 0;
2783                 r_shadow_bouncegrid_state.numphotons = 0;
2784                 r_shadow_bouncegrid_state.directional = false;
2785
2786                 if (!enable)
2787                         return;
2788         }
2789
2790         // if all the settings seem identical to the previous update, return
2791         if (r_shadow_bouncegrid_state.texture && (settings.staticmode || realtime < r_shadow_bouncegrid_state.lastupdatetime + r_shadow_bouncegrid_dynamic_updateinterval.value) && !settingschanged)
2792                 return;
2793
2794         // store the new settings
2795         r_shadow_bouncegrid_state.settings = settings;
2796
2797         R_Shadow_BounceGrid_UpdateSpacing();
2798
2799         // allocate the highpixels array we'll be accumulating light into
2800         if (r_shadow_bouncegrid_state.blurpixels[0] == NULL)
2801                 r_shadow_bouncegrid_state.blurpixels[0] = (float *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
2802         if (r_shadow_bouncegrid_state.settings.blur && r_shadow_bouncegrid_state.blurpixels[1] == NULL)
2803                 r_shadow_bouncegrid_state.blurpixels[1] = (float *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
2804         r_shadow_bouncegrid_state.highpixels_index = 0;
2805         r_shadow_bouncegrid_state.highpixels = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index];
2806
2807         // set up the tracking of photon data
2808         if (r_shadow_bouncegrid_state.photons == NULL)
2809                 r_shadow_bouncegrid_state.photons = (r_shadow_bouncegrid_photon_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(r_shadow_bouncegrid_photon_t));
2810         if (r_shadow_bouncegrid_state.photons_tasks == NULL)
2811                 r_shadow_bouncegrid_state.photons_tasks = (taskqueue_task_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(taskqueue_task_t));
2812         r_shadow_bouncegrid_state.numphotons = 0;
2813
2814         // set up the tracking of slice tasks
2815         if (r_shadow_bouncegrid_state.slices_tasks == NULL)
2816                 r_shadow_bouncegrid_state.slices_tasks = (taskqueue_task_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.resolution[2] * sizeof(taskqueue_task_t));
2817
2818         memset(&r_shadow_bouncegrid_state.cleartex_task, 0, sizeof(taskqueue_task_t));
2819         memset(&r_shadow_bouncegrid_state.assignphotons_task, 0, sizeof(taskqueue_task_t));
2820         memset(&r_shadow_bouncegrid_state.enqueuephotons_task, 0, sizeof(taskqueue_task_t));
2821         memset(r_shadow_bouncegrid_state.photons_tasks, 0, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(taskqueue_task_t));
2822         memset(&r_shadow_bouncegrid_state.photons_done_task, 0, sizeof(taskqueue_task_t));
2823         memset(&r_shadow_bouncegrid_state.enqueue_slices_task, 0, sizeof(taskqueue_task_t));
2824         memset(r_shadow_bouncegrid_state.slices_tasks, 0, r_shadow_bouncegrid_state.resolution[2] * sizeof(taskqueue_task_t));
2825         memset(&r_shadow_bouncegrid_state.slices_done_task, 0, sizeof(taskqueue_task_t));
2826         memset(&r_shadow_bouncegrid_state.blurpixels_task, 0, sizeof(taskqueue_task_t));
2827
2828         // clear the texture
2829         TaskQueue_Setup(&r_shadow_bouncegrid_state.cleartex_task, NULL, R_Shadow_BounceGrid_ClearTex_Task, 0, 0, NULL, NULL);
2830         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.cleartex_task);
2831
2832         // calculate weighting factors for distributing photons among the lights
2833         TaskQueue_Setup(&r_shadow_bouncegrid_state.assignphotons_task, NULL, R_Shadow_BounceGrid_AssignPhotons_Task, 0, 0, NULL, NULL);
2834         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.assignphotons_task);
2835
2836         // enqueue tasks to trace the photons from lights
2837         TaskQueue_Setup(&r_shadow_bouncegrid_state.enqueuephotons_task, &r_shadow_bouncegrid_state.assignphotons_task, R_Shadow_BounceGrid_EnqueuePhotons_Task, 0, 0, NULL, NULL);
2838         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.enqueuephotons_task);
2839
2840         // accumulate the light paths into texture
2841         TaskQueue_Setup(&r_shadow_bouncegrid_state.enqueue_slices_task, &r_shadow_bouncegrid_state.photons_done_task, R_Shadow_BounceGrid_EnqueueSlices_Task, 0, 0, NULL, NULL);
2842         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.enqueue_slices_task);
2843
2844         // apply a mild blur filter to the texture
2845         TaskQueue_Setup(&r_shadow_bouncegrid_state.blurpixels_task, &r_shadow_bouncegrid_state.slices_done_task, R_Shadow_BounceGrid_BlurPixels_Task, 0, 0, NULL, NULL);
2846         TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.blurpixels_task);
2847
2848         TaskQueue_WaitForTaskDone(&r_shadow_bouncegrid_state.blurpixels_task);
2849         R_TimeReport("bouncegrid_gen");
2850
2851         // convert the pixels to lower precision and upload the texture
2852         // this unfortunately has to run on the main thread for OpenGL calls, so we have to block on the previous task...
2853         R_Shadow_BounceGrid_ConvertPixelsAndUpload();
2854         R_TimeReport("bouncegrid_tex");
2855
2856         // after we compute the static lighting we don't need to keep the highpixels array around
2857         if (settings.staticmode)
2858         {
2859                 r_shadow_bouncegrid_state.highpixels = NULL;
2860                 if (r_shadow_bouncegrid_state.blurpixels[0]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[0]); r_shadow_bouncegrid_state.blurpixels[0] = NULL;
2861                 if (r_shadow_bouncegrid_state.blurpixels[1]) Mem_Free(r_shadow_bouncegrid_state.blurpixels[1]); r_shadow_bouncegrid_state.blurpixels[1] = NULL;
2862                 if (r_shadow_bouncegrid_state.u8pixels) Mem_Free(r_shadow_bouncegrid_state.u8pixels); r_shadow_bouncegrid_state.u8pixels = NULL;
2863                 if (r_shadow_bouncegrid_state.fp16pixels) Mem_Free(r_shadow_bouncegrid_state.fp16pixels); r_shadow_bouncegrid_state.fp16pixels = NULL;
2864                 if (r_shadow_bouncegrid_state.photons) Mem_Free(r_shadow_bouncegrid_state.photons); r_shadow_bouncegrid_state.photons = NULL;
2865                 if (r_shadow_bouncegrid_state.photons_tasks) Mem_Free(r_shadow_bouncegrid_state.photons_tasks); r_shadow_bouncegrid_state.photons_tasks = NULL;
2866                 if (r_shadow_bouncegrid_state.slices_tasks) Mem_Free(r_shadow_bouncegrid_state.slices_tasks); r_shadow_bouncegrid_state.slices_tasks = NULL;
2867         }
2868 }
2869
2870 void R_Shadow_RenderMode_VisibleLighting(qboolean transparent)
2871 {
2872         R_Shadow_RenderMode_Reset();
2873         GL_BlendFunc(GL_ONE, GL_ONE);
2874         GL_DepthRange(0, 1);
2875         GL_DepthTest(r_showlighting.integer < 2);
2876         GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2877         if (!transparent)
2878                 GL_DepthFunc(GL_EQUAL);
2879         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2880 }
2881
2882 void R_Shadow_RenderMode_End(void)
2883 {
2884         R_Shadow_RenderMode_Reset();
2885         R_Shadow_RenderMode_ActiveLight(NULL);
2886         GL_DepthMask(true);
2887         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2888         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2889 }
2890
2891 int bboxedges[12][2] =
2892 {
2893         // top
2894         {0, 1}, // +X
2895         {0, 2}, // +Y
2896         {1, 3}, // Y, +X
2897         {2, 3}, // X, +Y
2898         // bottom
2899         {4, 5}, // +X
2900         {4, 6}, // +Y
2901         {5, 7}, // Y, +X
2902         {6, 7}, // X, +Y
2903         // verticals
2904         {0, 4}, // +Z
2905         {1, 5}, // X, +Z
2906         {2, 6}, // Y, +Z
2907         {3, 7}, // XY, +Z
2908 };
2909
2910 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2911 {
2912         if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
2913         {
2914                 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2915                 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2916                 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2917                 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2918                 return false;
2919         }
2920         if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2921                 return true; // invisible
2922         if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2923         || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2924         || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2925         || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2926                 r_refdef.stats[r_stat_lights_scissored]++;
2927         return false;
2928 }
2929
2930 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
2931 {
2932         // used to display how many times a surface is lit for level design purposes
2933         RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
2934         R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
2935         RSurf_DrawBatch();
2936 }
2937
2938 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const float ambientcolor[3], const float diffusecolor[3], const float specularcolor[3])
2939 {
2940         // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
2941         R_SetupShader_Surface(ambientcolor, diffusecolor, specularcolor, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
2942         RSurf_DrawBatch();
2943 }
2944
2945 extern cvar_t gl_lightmaps;
2946 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
2947 {
2948         qboolean negated;
2949         float ambientcolor[3], diffusecolor[3], specularcolor[3];
2950         VectorM(rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient, rsurface.texture->render_rtlight_diffuse, ambientcolor);
2951         VectorM(rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient), rsurface.texture->render_rtlight_diffuse, diffusecolor);
2952         VectorM(rsurface.rtlight->specularscale, rsurface.texture->render_rtlight_specular, specularcolor);
2953         if (!r_shadow_usenormalmap.integer)
2954         {
2955                 VectorMAM(1.0f, ambientcolor, 1.0f, diffusecolor, ambientcolor);
2956                 VectorClear(diffusecolor);
2957                 VectorClear(specularcolor);
2958         }
2959         VectorMultiply(ambientcolor, rsurface.rtlight->currentcolor, ambientcolor);
2960         VectorMultiply(diffusecolor, rsurface.rtlight->currentcolor, diffusecolor);
2961         VectorMultiply(specularcolor, rsurface.rtlight->currentcolor, specularcolor);
2962         if (VectorLength2(ambientcolor) + VectorLength2(diffusecolor) + VectorLength2(specularcolor) < (1.0f / 1048576.0f))
2963                 return;
2964         negated = (rsurface.rtlight->currentcolor[0] + rsurface.rtlight->currentcolor[1] + rsurface.rtlight->currentcolor[2] < 0);
2965         if(negated)
2966         {
2967                 VectorNegate(ambientcolor, ambientcolor);
2968                 VectorNegate(diffusecolor, diffusecolor);
2969                 VectorNegate(specularcolor, specularcolor);
2970                 GL_BlendEquationSubtract(true);
2971         }
2972         RSurf_SetupDepthAndCulling();
2973         switch (r_shadow_rendermode)
2974         {
2975         case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2976                 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2977                 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
2978                 break;
2979         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2980                 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, ambientcolor, diffusecolor, specularcolor);
2981                 break;
2982         default:
2983                 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2984                 break;
2985         }
2986         if(negated)
2987                 GL_BlendEquationSubtract(false);
2988 }
2989
2990 void R_RTLight_Update(rtlight_t *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)
2991 {
2992         matrix4x4_t tempmatrix = *matrix;
2993         Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
2994
2995         // if this light has been compiled before, free the associated data
2996         R_RTLight_Uncompile(rtlight);
2997
2998         // clear it completely to avoid any lingering data
2999         memset(rtlight, 0, sizeof(*rtlight));
3000
3001         // copy the properties
3002         rtlight->matrix_lighttoworld = tempmatrix;
3003         Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3004         Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3005         rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3006         VectorCopy(color, rtlight->color);
3007         rtlight->cubemapname[0] = 0;
3008         if (cubemapname && cubemapname[0])
3009                 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3010         rtlight->shadow = shadow;
3011         rtlight->corona = corona;
3012         rtlight->style = style;
3013         rtlight->isstatic = isstatic;
3014         rtlight->coronasizescale = coronasizescale;
3015         rtlight->ambientscale = ambientscale;
3016         rtlight->diffusescale = diffusescale;
3017         rtlight->specularscale = specularscale;
3018         rtlight->flags = flags;
3019
3020         // compute derived data
3021         //rtlight->cullradius = rtlight->radius;
3022         //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3023         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3024         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3025         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3026         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3027         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3028         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3029 }
3030
3031 // compiles rtlight geometry
3032 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3033 void R_RTLight_Compile(rtlight_t *rtlight)
3034 {
3035         int i;
3036         int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3037         int lighttris, shadowtris;
3038         entity_render_t *ent = r_refdef.scene.worldentity;
3039         dp_model_t *model = r_refdef.scene.worldmodel;
3040         unsigned char *data;
3041
3042         // compile the light
3043         rtlight->compiled = true;
3044         rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3045         rtlight->static_numleafs = 0;
3046         rtlight->static_numleafpvsbytes = 0;
3047         rtlight->static_leaflist = NULL;
3048         rtlight->static_leafpvs = NULL;
3049         rtlight->static_numsurfaces = 0;
3050         rtlight->static_surfacelist = NULL;
3051         rtlight->static_shadowmap_receivers = 0x3F;
3052         rtlight->static_shadowmap_casters = 0x3F;
3053         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3054         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3055         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3056         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3057         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3058         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3059
3060         if (model && model->GetLightInfo)
3061         {
3062                 // this variable must be set for the CompileShadowMap code
3063                 r_shadow_compilingrtlight = rtlight;
3064                 R_FrameData_SetMark();
3065                 model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs, r_shadow_buffer_visitingleafpvs, 0, NULL, rtlight->shadow == 0);
3066                 R_FrameData_ReturnToMark();
3067                 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3068                 numshadowtrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3069                 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3070                 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3071                 rtlight->static_numsurfaces = numsurfaces;
3072                 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3073                 rtlight->static_numleafs = numleafs;
3074                 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3075                 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3076                 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3077                 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3078                 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3079                 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3080                 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3081                 if (rtlight->static_numsurfaces)
3082                         memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3083                 if (rtlight->static_numleafs)
3084                         memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3085                 if (rtlight->static_numleafpvsbytes)
3086                         memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3087                 if (rtlight->static_numshadowtrispvsbytes)
3088                         memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3089                 if (rtlight->static_numlighttrispvsbytes)
3090                         memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3091                 R_FrameData_SetMark();
3092                 if (model->CompileShadowMap && rtlight->shadow)
3093                         model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3094                 R_FrameData_ReturnToMark();
3095                 // now we're done compiling the rtlight
3096                 r_shadow_compilingrtlight = NULL;
3097         }
3098
3099
3100         // use smallest available cullradius - box radius or light radius
3101         //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3102         //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3103
3104         lighttris = 0;
3105         if (rtlight->static_numlighttrispvsbytes)
3106                 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3107                         if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3108                                 lighttris++;
3109
3110         shadowtris = 0;
3111         if (rtlight->static_numshadowtrispvsbytes)
3112                 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3113                         if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3114                                 shadowtris++;
3115
3116         if (developer_extra.integer)
3117                 Con_DPrintf("static light built: %f %f %f : %f %f %f box, %i light triangles, %i shadow triangles\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], lighttris, shadowtris);
3118 }
3119
3120 void R_RTLight_Uncompile(rtlight_t *rtlight)
3121 {
3122         if (rtlight->compiled)
3123         {
3124                 if (rtlight->static_meshchain_shadow_shadowmap)
3125                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3126                 rtlight->static_meshchain_shadow_shadowmap = NULL;
3127                 // these allocations are grouped
3128                 if (rtlight->static_surfacelist)
3129                         Mem_Free(rtlight->static_surfacelist);
3130                 rtlight->static_numleafs = 0;
3131                 rtlight->static_numleafpvsbytes = 0;
3132                 rtlight->static_leaflist = NULL;
3133                 rtlight->static_leafpvs = NULL;
3134                 rtlight->static_numsurfaces = 0;
3135                 rtlight->static_surfacelist = NULL;
3136                 rtlight->static_numshadowtrispvsbytes = 0;
3137                 rtlight->static_shadowtrispvs = NULL;
3138                 rtlight->static_numlighttrispvsbytes = 0;
3139                 rtlight->static_lighttrispvs = NULL;
3140                 rtlight->compiled = false;
3141         }
3142 }
3143
3144 void R_Shadow_UncompileWorldLights(void)
3145 {
3146         size_t lightindex;
3147         dlight_t *light;
3148         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3149         for (lightindex = 0;lightindex < range;lightindex++)
3150         {
3151                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3152                 if (!light)
3153                         continue;
3154                 R_RTLight_Uncompile(&light->rtlight);
3155         }
3156 }
3157
3158 static void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3159 {
3160         int i, j;
3161         mplane_t plane;
3162         // reset the count of frustum planes
3163         // see rtlight->cached_frustumplanes definition for how much this array
3164         // can hold
3165         rtlight->cached_numfrustumplanes = 0;
3166
3167         if (r_trippy.integer)
3168                 return;
3169
3170         // haven't implemented a culling path for ortho rendering
3171         if (!r_refdef.view.useperspective)
3172         {
3173                 // check if the light is on screen and copy the 4 planes if it is
3174                 for (i = 0;i < 4;i++)
3175                         if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3176                                 break;
3177                 if (i == 4)
3178                         for (i = 0;i < 4;i++)
3179                                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3180                 return;
3181         }
3182
3183 #if 1
3184         // generate a deformed frustum that includes the light origin, this is
3185         // used to cull shadow casting surfaces that can not possibly cast a
3186         // shadow onto the visible light-receiving surfaces, which can be a
3187         // performance gain
3188         //
3189         // if the light origin is onscreen the result will be 4 planes exactly
3190         // if the light origin is offscreen on only one axis the result will
3191         // be exactly 5 planes (split-side case)
3192         // if the light origin is offscreen on two axes the result will be
3193         // exactly 4 planes (stretched corner case)
3194         for (i = 0;i < 4;i++)
3195         {
3196                 // quickly reject standard frustum planes that put the light
3197                 // origin outside the frustum
3198                 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3199                         continue;
3200                 // copy the plane
3201                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3202         }
3203         // if all the standard frustum planes were accepted, the light is onscreen
3204         // otherwise we need to generate some more planes below...
3205         if (rtlight->cached_numfrustumplanes < 4)
3206         {
3207                 // at least one of the stock frustum planes failed, so we need to
3208                 // create one or two custom planes to enclose the light origin
3209                 for (i = 0;i < 4;i++)
3210                 {
3211                         // create a plane using the view origin and light origin, and a
3212                         // single point from the frustum corner set
3213                         TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3214                         VectorNormalize(plane.normal);
3215                         plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3216                         // see if this plane is backwards and flip it if so
3217                         for (j = 0;j < 4;j++)
3218                                 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3219                                         break;
3220                         if (j < 4)
3221                         {
3222                                 VectorNegate(plane.normal, plane.normal);
3223                                 plane.dist *= -1;
3224                                 // flipped plane, test again to see if it is now valid
3225                                 for (j = 0;j < 4;j++)
3226                                         if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3227                                                 break;
3228                                 // if the plane is still not valid, then it is dividing the
3229                                 // frustum and has to be rejected
3230                                 if (j < 4)
3231                                         continue;
3232                         }
3233                         // we have created a valid plane, compute extra info
3234                         PlaneClassify(&plane);
3235                         // copy the plane
3236                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3237 #if 1
3238                         // if we've found 5 frustum planes then we have constructed a
3239                         // proper split-side case and do not need to keep searching for
3240                         // planes to enclose the light origin
3241                         if (rtlight->cached_numfrustumplanes == 5)
3242                                 break;
3243 #endif
3244                 }
3245         }
3246 #endif
3247
3248 #if 0
3249         for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3250         {
3251                 plane = rtlight->cached_frustumplanes[i];
3252                 Con_Printf("light %p plane #%i %f %f %f : %f (%f %f %f %f %f)\n", rtlight, i, plane.normal[0], plane.normal[1], plane.normal[2], plane.dist, PlaneDiff(r_refdef.view.frustumcorner[0], &plane), PlaneDiff(r_refdef.view.frustumcorner[1], &plane), PlaneDiff(r_refdef.view.frustumcorner[2], &plane), PlaneDiff(r_refdef.view.frustumcorner[3], &plane), PlaneDiff(rtlight->shadoworigin, &plane));
3253         }
3254 #endif
3255
3256 #if 0
3257         // now add the light-space box planes if the light box is rotated, as any
3258         // caster outside the oriented light box is irrelevant (even if it passed
3259         // the worldspace light box, which is axial)
3260         if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3261         {
3262                 for (i = 0;i < 6;i++)
3263                 {
3264                         vec3_t v;
3265                         VectorClear(v);
3266                         v[i >> 1] = (i & 1) ? -1 : 1;
3267                         Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3268                         VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3269                         plane.dist = VectorNormalizeLength(plane.normal);
3270                         plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3271                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3272                 }
3273         }
3274 #endif
3275
3276 #if 0
3277         // add the world-space reduced box planes
3278         for (i = 0;i < 6;i++)
3279         {
3280                 VectorClear(plane.normal);
3281                 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3282                 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3283                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3284         }
3285 #endif
3286
3287 #if 0
3288         {
3289         int j, oldnum;
3290         vec3_t points[8];
3291         vec_t bestdist;
3292         // reduce all plane distances to tightly fit the rtlight cull box, which
3293         // is in worldspace
3294         VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3295         VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3296         VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3297         VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3298         VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3299         VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3300         VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3301         VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3302         oldnum = rtlight->cached_numfrustumplanes;
3303         rtlight->cached_numfrustumplanes = 0;
3304         for (j = 0;j < oldnum;j++)
3305         {
3306                 // find the nearest point on the box to this plane
3307                 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3308                 for (i = 1;i < 8;i++)
3309                 {
3310                         dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3311                         if (bestdist > dist)
3312                                 bestdist = dist;
3313                 }
3314                 Con_Printf("light %p %splane #%i %f %f %f : %f < %f\n", rtlight, rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125 ? "^2" : "^1", j, rtlight->cached_frustumplanes[j].normal[0], rtlight->cached_frustumplanes[j].normal[1], rtlight->cached_frustumplanes[j].normal[2], rtlight->cached_frustumplanes[j].dist, bestdist);
3315                 // if the nearest point is near or behind the plane, we want this
3316                 // plane, otherwise the plane is useless as it won't cull anything
3317                 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3318                 {
3319                         PlaneClassify(&rtlight->cached_frustumplanes[j]);
3320                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3321                 }
3322         }
3323         }
3324 #endif
3325 }
3326
3327 static void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3328 {
3329         RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
3330
3331         if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3332         {
3333                 shadowmesh_t *mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3334                 if (mesh->sidetotals[r_shadow_shadowmapside])
3335                 {
3336                         CHECKGLERROR
3337                         GL_CullFace(GL_NONE);
3338                         r_refdef.stats[r_stat_lights_shadowtriangles] += mesh->sidetotals[r_shadow_shadowmapside];
3339                         R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer, mesh->vbooffset_vertex3f);
3340                         R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
3341                         CHECKGLERROR
3342                 }
3343         }
3344         else if (r_refdef.scene.worldentity->model)
3345                 r_refdef.scene.worldmodel->DrawShadowMap(r_shadow_shadowmapside, r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, surfacesides, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs);
3346
3347         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
3348 }
3349
3350 static void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3351 {
3352         vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3353         vec_t relativeshadowradius;
3354         RSurf_ActiveModelEntity(ent, false, false, false);
3355         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3356         // we need to re-init the shader for each entity because the matrix changed
3357         relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3358         relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3359         relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3360         relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3361         relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3362         relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3363         relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3364         ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3365         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
3366 }
3367
3368 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3369 {
3370         // set up properties for rendering light onto this entity
3371         RSurf_ActiveModelEntity(ent, true, true, false);
3372         Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3373         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3374         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3375         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3376 }
3377
3378 static void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3379 {
3380         if (!r_refdef.scene.worldmodel->DrawLight)
3381                 return;
3382
3383         // set up properties for rendering light onto this entity
3384         RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
3385         rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3386         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3387         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3388         VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3389
3390         r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3391
3392         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
3393 }
3394
3395 static void R_Shadow_DrawEntityLight(entity_render_t *ent)
3396 {
3397         dp_model_t *model = ent->model;
3398         if (!model->DrawLight)
3399                 return;
3400
3401         R_Shadow_SetupEntityLight(ent);
3402
3403         model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3404
3405         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
3406 }
3407
3408 static void R_Shadow_PrepareLight(rtlight_t *rtlight)
3409 {
3410         int i;
3411         float f;
3412         int numleafs, numsurfaces;
3413         int *leaflist,