rtexture_t *r_shadow_prepasslightingdiffusetexture;
rtexture_t *r_shadow_prepasslightingspeculartexture;
-// keep track of the provided framebuffer info
-static int r_shadow_fb_fbo;
-static rtexture_t *r_shadow_fb_depthtexture;
-static rtexture_t *r_shadow_fb_colortexture;
+int r_shadow_viewfbo;
+rtexture_t *r_shadow_viewdepthtexture;
+rtexture_t *r_shadow_viewcolortexture;
+int r_shadow_viewx;
+int r_shadow_viewy;
+int r_shadow_viewwidth;
+int r_shadow_viewheight;
// lights are reloaded when this changes
char r_shadow_mapname[MAX_QPATH];
cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};
cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
-cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "1", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"};
+cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "1", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes"};
cvar_t r_shadow_shadowmapping_filterquality = {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)"};
cvar_t r_shadow_shadowmapping_useshadowsampler = {CVAR_SAVE, "r_shadow_shadowmapping_useshadowsampler", "1", "whether to use sampler2DShadow if available"};
cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "limit of shadowmap side size - must be at least r_shadow_shadowmapping_bordersize+2"};
cvar_t r_shadow_shadowmapping_maxsize = {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..."};
-cvar_t r_shadow_shadowmapping_texturesize = { CVAR_SAVE, "r_shadow_shadowmapping_texturesize", "4096", "size of shadowmap atlas texture - all shadowmaps are packed into this texture at frame start"};
+cvar_t r_shadow_shadowmapping_texturesize = { CVAR_SAVE, "r_shadow_shadowmapping_texturesize", "8192", "size of shadowmap atlas texture - all shadowmaps are packed into this texture at frame start"};
cvar_t r_shadow_shadowmapping_precision = {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"};
//cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
//cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
-cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
+cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "5", "shadowmap size bias for filtering"};
cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect OpenGL 2.0 render path)"};
+cvar_t r_shadow_culllights_pvs = {CVAR_SAVE, "r_shadow_culllights_pvs", "1", "check if light overlaps any visible bsp leafs when determining if the light is visible"};
+cvar_t r_shadow_culllights_trace = {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"};
+cvar_t r_shadow_culllights_trace_eyejitter = {CVAR_SAVE, "r_shadow_culllights_trace_eyejitter", "16", "offset eye location randomly by this much"};
+cvar_t r_shadow_culllights_trace_enlarge = {CVAR_SAVE, "r_shadow_culllights_trace_enlarge", "0", "make light bounds bigger by *(1.0+enlarge)"};
+cvar_t r_shadow_culllights_trace_expand = {CVAR_SAVE, "r_shadow_culllights_trace_expand", "8", "make light bounds bigger by this many units"};
+cvar_t r_shadow_culllights_trace_pad = {CVAR_SAVE, "r_shadow_culllights_trace_expand", "8", "accept traces that hit within this many units of the light bounds"};
+cvar_t r_shadow_culllights_trace_samples = {CVAR_SAVE, "r_shadow_culllights_trace_samples", "16", "use this many traces to random positions (in addition to center trace)"};
+cvar_t r_shadow_culllights_trace_tempsamples = {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)"};
+cvar_t r_shadow_culllights_trace_delay = {CVAR_SAVE, "r_shadow_culllights_trace_delay", "1", "light will be considered visible for this many seconds after any trace connects"};
cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, only active on levels with realtime lights active (r_shadow_realtime_world is usually required for these)"};
cvar_t r_shadow_bouncegrid_blur = {CVAR_SAVE, "r_shadow_bouncegrid_blur", "0", "apply a 1-radius blur on bouncegrid to denoise it and deal with boundary issues with surfaces"};
cvar_t r_shadow_bouncegrid_bounceanglediffuse = {CVAR_SAVE, "r_shadow_bouncegrid_bounceanglediffuse", "0", "use random bounce direction rather than true reflection, makes some corner areas dark"};
{
if (!r_fb.usedepthtextures)
r_shadow_shadowmappcf = 1;
- else if((strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD")) && vid.support.arb_shadow && r_shadow_shadowmapshadowsampler)
+ else if((strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD")) && vid.support.arb_shadow && r_shadow_shadowmapshadowsampler)
{
r_shadow_shadowmapsampler = true;
r_shadow_shadowmappcf = 1;
}
else if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
r_shadow_shadowmappcf = 1;
- else if((strstr(gl_vendor, "ATI") || strstr(gl_vendor, "Advanced Micro Devices")) && !strstr(gl_renderer, "Mesa") && !strstr(gl_version, "Mesa"))
+ else if((strstr(gl_vendor, "ATI") || strstr(gl_vendor, "Advanced Micro Devices")) && !strstr(gl_renderer, "Mesa") && !strstr(gl_version, "Mesa"))
r_shadow_shadowmappcf = 1;
- else
+ else
r_shadow_shadowmapsampler = vid.support.arb_shadow && r_shadow_shadowmapshadowsampler;
}
- else
+ else
{
r_shadow_shadowmapsampler = vid.support.arb_shadow && r_shadow_shadowmapshadowsampler;
switch (r_shadow_shadowmapfilterquality)
Cvar_RegisterVariable(&r_shadow_polygonfactor);
Cvar_RegisterVariable(&r_shadow_polygonoffset);
Cvar_RegisterVariable(&r_shadow_texture3d);
+ Cvar_RegisterVariable(&r_shadow_culllights_pvs);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_eyejitter);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_enlarge);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_expand);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_pad);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_samples);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_tempsamples);
+ Cvar_RegisterVariable(&r_shadow_culllights_trace_delay);
Cvar_RegisterVariable(&r_shadow_bouncegrid);
Cvar_RegisterVariable(&r_shadow_bouncegrid_blur);
Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
float scale = (size - 2*border)/size, len;
float bias = border / (float)(size - border), dp, dn, ap, an;
- // check if cone enclosing side would cross frustum plane
+ // check if cone enclosing side would cross frustum plane
scale = 2 / (scale*scale + 2);
Matrix4x4_OriginFromMatrix(&rtlight->matrix_lighttoworld, o);
for (i = 0;i < 5;i++)
void R_Shadow_RenderMode_Reset(void)
{
R_Mesh_ResetTextureState();
- R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
+ R_Mesh_SetRenderTargets(r_shadow_viewfbo, r_shadow_viewdepthtexture, r_shadow_viewcolortexture, NULL, NULL, NULL);
R_SetViewport(&r_refdef.view.viewport);
GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
GL_DepthRange(0, 1);
float bounceminimumintensity = s ? r_shadow_bouncegrid_static_bounceminimumintensity.value : r_shadow_bouncegrid_dynamic_bounceminimumintensity.value;
// prevent any garbage in alignment padded areas as we'll be using memcmp
- memset(settings, 0, sizeof(*settings));
+ memset(settings, 0, sizeof(*settings));
// build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
settings->staticmode = s;
// calculate texture size enclosing entire world bounds at the spacing
if (r_refdef.scene.worldmodel)
{
- VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
- VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
+ int lightindex;
+ int range;
+ qboolean bounds_set = false;
+ dlight_t *light;
+ rtlight_t *rtlight;
+
+ // calculate bounds enclosing world lights as they should be noticably tighter
+ // than the world bounds on maps with unlit monster containers (see e1m7 etc)
+ range = (unsigned int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+ for (lightindex = 0;lightindex < range;lightindex++)
+ {
+ const vec_t *rtlmins, *rtlmaxs;
+
+ light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+ if (!light)
+ continue;
+
+ rtlight = &light->rtlight;
+ rtlmins = rtlight->cullmins;
+ rtlmaxs = rtlight->cullmaxs;
+
+ if (!bounds_set)
+ {
+ VectorCopy(rtlmins, mins);
+ VectorCopy(rtlmaxs, maxs);
+ bounds_set = true;
+ }
+ else
+ {
+ mins[0] = min(mins[0], rtlmins[0]);
+ mins[1] = min(mins[1], rtlmins[1]);
+ mins[2] = min(mins[2], rtlmins[2]);
+ maxs[0] = max(maxs[0], rtlmaxs[0]);
+ maxs[1] = max(maxs[1], rtlmaxs[1]);
+ maxs[2] = max(maxs[2], rtlmaxs[2]);
+ }
+ }
+
+ // limit to no larger than the world bounds
+ mins[0] = max(mins[0], r_refdef.scene.worldmodel->normalmins[0]);
+ mins[1] = max(mins[1], r_refdef.scene.worldmodel->normalmins[1]);
+ mins[2] = max(mins[2], r_refdef.scene.worldmodel->normalmins[2]);
+ maxs[0] = min(maxs[0], r_refdef.scene.worldmodel->normalmaxs[0]);
+ maxs[1] = min(maxs[1], r_refdef.scene.worldmodel->normalmaxs[1]);
+ maxs[2] = min(maxs[2], r_refdef.scene.worldmodel->normalmaxs[2]);
+
+ VectorMA(mins, -2.0f, spacing, mins);
+ VectorMA(maxs, 2.0f, spacing, maxs);
}
else
{
w = r_shadow_lightintensityscale.value * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
if (!settings->staticmode)
{
- if (R_CullBox(cullmins, cullmaxs))
- continue;
+ // skip if the expanded light box does not touch any visible leafs
if (r_refdef.scene.worldmodel
- && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
- && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
+ && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
+ && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
+ continue;
+ // skip if the expanded light box is not visible to traceline
+ // note that PrepareLight already did this check but for a smaller box, so we
+ // end up casting more traces per frame per light when using bouncegrid, which
+ // is probably fine (and they use the same timer)
+ if (r_shadow_culllights_trace.integer)
+ {
+ 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))
+ rtlight->trace_timer = realtime;
+ if (realtime - rtlight->trace_timer > r_shadow_culllights_trace_delay.value)
+ return;
+ }
+ // skip if expanded light box is offscreen
+ if (R_CullBox(cullmins, cullmaxs))
continue;
+ // skip if overall light intensity is zero
if (w * VectorLength2(rtlight->color) == 0.0f)
continue;
}
int bouncecount;
int hitsupercontentsmask;
int skipsupercontentsmask;
+ int skipmaterialflagsmask;
int maxbounce;
int shootparticles;
int shotparticles;
// figure out what we want to interact with
if (settings.hitmodels)
- hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
+ hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
else
hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
- skipsupercontentsmask = SUPERCONTENTS_SKY; // this allows the e1m5 sky shadow to work by ignoring the sky surfaces
+ skipsupercontentsmask = 0;
+ skipmaterialflagsmask = MATERIALFLAGMASK_TRANSLUCENT;
maxbounce = settings.maxbounce;
for (lightindex = 0;lightindex < range2;lightindex++)
{
// static mode fires a LOT of rays but none of them are identical, so they are not cached
// non-stable random in dynamic mode also never reuses a direction, so there's no reason to cache it
- cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, skipsupercontentsmask, collision_extendmovelength.value, true, false, NULL, true, true);
+ cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true, false, NULL, true, true);
}
else
{
// dynamic mode fires many rays and most will match the cache from the previous frame
- cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask, skipsupercontentsmask);
+ cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
}
if (bouncecount > 0 || settings.includedirectlighting)
{
RSurf_DrawBatch();
}
-static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
+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])
{
// ARB2 GLSL shader path (GFFX5200, Radeon 9500)
- R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
+ R_SetupShader_Surface(ambientcolor, diffusecolor, specularcolor, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
RSurf_DrawBatch();
}
}
}
-static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
+static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const float ambientcolor[3], const float diffusecolor[3])
{
// OpenGL 1.1 path (anything)
float ambientcolorbase[3], diffusecolorbase[3];
float ambientcolorpants[3], diffusecolorpants[3];
float ambientcolorshirt[3], diffusecolorshirt[3];
- const float *surfacecolor = rsurface.texture->dlightcolor;
- const float *surfacepants = rsurface.colormap_pantscolor;
- const float *surfaceshirt = rsurface.colormap_shirtcolor;
+ const float *surfacepants = rsurface.texture->render_colormap_pants;
+ const float *surfaceshirt = rsurface.texture->render_colormap_shirt;
rtexture_t *basetexture = rsurface.texture->basetexture;
rtexture_t *pantstexture = rsurface.texture->pantstexture;
rtexture_t *shirttexture = rsurface.texture->shirttexture;
qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
- ambientscale *= 2 * r_refdef.view.colorscale;
- diffusescale *= 2 * r_refdef.view.colorscale;
- ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
- diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
+ VectorCopy(ambientcolor, ambientcolorbase);
+ VectorCopy(diffusecolor, diffusecolorbase);
ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
- RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
+ RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (VectorLength2(diffusecolor) > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
extern cvar_t gl_lightmaps;
void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
{
- float ambientscale, diffusescale, specularscale;
qboolean negated;
- float lightcolor[3];
- VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
- ambientscale = rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient;
- diffusescale = rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient);
- specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
+ float ambientcolor[3], diffusecolor[3], specularcolor[3];
+ VectorM(rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient, rsurface.texture->render_rtlight_diffuse, ambientcolor);
+ VectorM(rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient), rsurface.texture->render_rtlight_diffuse, diffusecolor);
+ VectorM(rsurface.rtlight->specularscale, rsurface.texture->render_rtlight_specular, specularcolor);
if (!r_shadow_usenormalmap.integer)
{
- ambientscale += 1.0f * diffusescale;
- diffusescale = 0;
- specularscale = 0;
+ VectorMAM(1.0f, ambientcolor, 1.0f, diffusecolor, ambientcolor);
+ VectorClear(diffusecolor);
+ VectorClear(specularcolor);
}
- if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
+ VectorMultiply(ambientcolor, rsurface.rtlight->currentcolor, ambientcolor);
+ VectorMultiply(diffusecolor, rsurface.rtlight->currentcolor, diffusecolor);
+ VectorMultiply(specularcolor, rsurface.rtlight->currentcolor, specularcolor);
+ if (VectorLength2(ambientcolor) + VectorLength2(diffusecolor) + VectorLength2(specularcolor) < (1.0f / 1048576.0f))
return;
- negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
+ negated = (rsurface.rtlight->currentcolor[0] + rsurface.rtlight->currentcolor[1] + rsurface.rtlight->currentcolor[2] < 0) && vid.support.ext_blend_subtract;
if(negated)
{
- VectorNegate(lightcolor, lightcolor);
+ VectorNegate(ambientcolor, ambientcolor);
+ VectorNegate(diffusecolor, diffusecolor);
+ VectorNegate(specularcolor, specularcolor);
GL_BlendEquationSubtract(true);
}
RSurf_SetupDepthAndCulling();
R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
break;
case R_SHADOW_RENDERMODE_LIGHT_GLSL:
- R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
+ R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, ambientcolor, diffusecolor, specularcolor);
break;
case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
- R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
+ R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, ambientcolor, diffusecolor);
break;
default:
Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
// this variable must be set for the CompileShadowVolume/CompileShadowMap code
r_shadow_compilingrtlight = rtlight;
R_FrameData_SetMark();
- 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);
+ 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);
R_FrameData_ReturnToMark();
numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
{
shadowmesh_t *mesh;
- RSurf_ActiveWorldEntity();
+ RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
{
else if (r_refdef.scene.worldentity->model)
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);
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
static void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
return;
- RSurf_ActiveWorldEntity();
+ RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
{
r_refdef.scene.worldmodel->DrawShadowVolume(r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs);
}
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
static void R_Shadow_DrawEntityShadow(entity_render_t *ent)
ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
break;
}
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
void R_Shadow_SetupEntityLight(const entity_render_t *ent)
return;
// set up properties for rendering light onto this entity
- RSurf_ActiveWorldEntity();
+ RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
static void R_Shadow_DrawEntityLight(entity_render_t *ent)
model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
static void R_Shadow_PrepareLight(rtlight_t *rtlight)
}
*/
- // if lightstyle is currently off, don't draw the light
+ // skip if lightstyle is currently off
if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
return;
if (nolight)
return;
- // if the light box is offscreen, skip it
+ // skip if the light box is not touching any visible leafs
+ if (r_shadow_culllights_pvs.integer
+ && r_refdef.scene.worldmodel
+ && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
+ && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, rtlight->cullmins, rtlight->cullmaxs))
+ return;
+
+ // skip if the light box is not visible to traceline
+ if (r_shadow_culllights_trace.integer)
+ {
+ 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))
+ rtlight->trace_timer = realtime;
+ if (realtime - rtlight->trace_timer > r_shadow_culllights_trace_delay.value)
+ return;
+ }
+
+ // skip if the light box is off screen
if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
return;
+ // in the typical case this will be quickly replaced by GetLightInfo
VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
{
// dynamic light, world available and can receive realtime lighting
// calculate lit surfaces and leafs
- r_refdef.scene.worldmodel->GetLightInfo(r_refdef.scene.worldentity, rtlight->shadoworigin, rtlight->radius, rtlight->cached_cullmins, rtlight->cached_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, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes);
+ r_refdef.scene.worldmodel->GetLightInfo(r_refdef.scene.worldentity, rtlight->shadoworigin, rtlight->radius, rtlight->cached_cullmins, rtlight->cached_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, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes, rtlight->shadow == 0);
R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
leaflist = r_shadow_buffer_leaflist;
leafpvs = r_shadow_buffer_leafpvs;
}
void R_Shadow_DrawLightSprites(void);
-void R_Shadow_PrepareLights(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
+void R_Shadow_PrepareLights(void)
{
int flag;
int lnum;
r_shadow_shadowmapdepthtexture != r_fb.usedepthtextures)
R_Shadow_FreeShadowMaps();
- r_shadow_fb_fbo = fbo;
- r_shadow_fb_depthtexture = depthtexture;
- r_shadow_fb_colortexture = colortexture;
-
r_shadow_usingshadowmaportho = false;
switch (vid.renderpath)
r_shadow_nummodelshadows = 0;
r_shadow_shadowmapatlas_modelshadows_size = 0;
- if (!r_refdef.scene.numentities || r_refdef.lightmapintensity <= 0.0f || r_shadows.integer <= 0)
+ if (!r_refdef.scene.numentities || r_refdef.scene.lightmapintensity <= 0.0f || r_shadows.integer <= 0)
return;
switch (r_shadow_shadowmode)
return;
}
- size = 2 * r_shadow_shadowmapmaxsize;
+ size = r_shadow_shadowmaptexturesize / 4;
scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
radius = 0.5f * size / scale;
VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
dot1 = DotProduct(r_refdef.view.forward, shadowdir);
dot2 = DotProduct(r_refdef.view.up, shadowdir);
- if (fabs(dot1) <= fabs(dot2))
+ if (fabs(dot1) <= fabs(dot2))
VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
else
VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
RSurf_ActiveModelEntity(ent, false, false, false);
ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
#if 0
Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
- Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
+ Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
if (!r_shadow_nummodelshadows || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
return;
- R_ResetViewRendering3D(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture);
+ R_ResetViewRendering3D(r_shadow_viewfbo, r_shadow_viewdepthtexture, r_shadow_viewcolortexture, r_shadow_viewx, r_shadow_viewy, r_shadow_viewwidth, r_shadow_viewheight);
//GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
//GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
R_Shadow_RenderMode_Begin();
R_Shadow_RenderMode_ActiveLight(NULL);
- r_shadow_lightscissor[0] = r_refdef.view.x;
- r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
- r_shadow_lightscissor[2] = r_refdef.view.width;
- r_shadow_lightscissor[3] = r_refdef.view.height;
+ r_shadow_lightscissor[0] = r_shadow_viewx;
+ r_shadow_lightscissor[1] = (r_shadow_viewfbo ? r_shadow_viewheight : vid.height) - r_shadow_viewy - r_shadow_viewheight;
+ r_shadow_lightscissor[2] = r_shadow_viewwidth;
+ r_shadow_lightscissor[3] = r_shadow_viewheight;
R_Shadow_RenderMode_StencilShadowVolumes(false);
// get shadow dir
Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
else
{
- if(ent->entitynumber != 0)
- {
- if(ent->entitynumber >= MAX_EDICTS) // csqc entity
- {
- // FIXME handle this
- VectorNegate(ent->modellight_lightdir, relativelightdirection);
- }
- else
- {
- // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
- int entnum, entnum2, recursion;
- entnum = entnum2 = ent->entitynumber;
- for(recursion = 32; recursion > 0; --recursion)
- {
- entnum2 = cl.entities[entnum].state_current.tagentity;
- if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
- entnum = entnum2;
- else
- break;
- }
- if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
- {
- VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
- // transform into modelspace of OUR entity
- Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
- Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
- }
- else
- VectorNegate(ent->modellight_lightdir, relativelightdirection);
- }
- }
- else
- VectorNegate(ent->modellight_lightdir, relativelightdirection);
+ VectorNegate(ent->render_modellight_lightdir, tmp);
+ Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
}
VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
RSurf_ActiveModelEntity(ent, false, false, false);
ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
- rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+ rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}
// not really the right mode, but this will disable any silly stencil features
//GL_ScissorTest(true);
//R_EntityMatrix(&identitymatrix);
//R_Mesh_ResetTextureState();
- R_ResetViewRendering2D(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture);
+ R_ResetViewRendering2D(r_shadow_viewfbo, r_shadow_viewdepthtexture, r_shadow_viewcolortexture, r_shadow_viewx, r_shadow_viewy, r_shadow_viewwidth, r_shadow_viewheight);
// set up a darkening blend on shadowed areas
GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
{
switch(vid.renderpath)
{
- case RENDERPATH_GL11:
- case RENDERPATH_GL13:
case RENDERPATH_GL20:
case RENDERPATH_GLES1:
case RENDERPATH_GLES2:
#if defined(GL_SAMPLES_PASSED_ARB) && !defined(USE_GLES2)
- CHECKGLERROR
// See if we can use the GPU-side method to prevent implicit sync
if (vid.support.arb_query_buffer_object) {
#define BUFFER_OFFSET(i) ((GLint *)((unsigned char*)NULL + (i)))
qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, BUFFER_OFFSET(4));
qglBindBufferBase(GL_UNIFORM_BUFFER, 0, r_shadow_occlusion_buf);
occlude = MATERIALFLAG_OCCLUDE;
- } else {
- qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
- qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
- if (visiblepixels < 1 || allpixels < 1)
- return;
- rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
+ cscale *= rtlight->corona_visibility;
+ CHECKGLERROR
+ break;
}
+ // fallthrough
+#else
+ return;
+#endif
+ case RENDERPATH_GL11:
+ case RENDERPATH_GL13:
+#if defined(GL_SAMPLES_PASSED_ARB) && !defined(USE_GLES2)
+ CHECKGLERROR
+ qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
+ qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
+ if (visiblepixels < 1 || allpixels < 1)
+ return;
+ rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
cscale *= rtlight->corona_visibility;
CHECKGLERROR
break;
}
else
{
- // FIXME: these traces should scan all render entities instead of cl.world
- if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (CL_Cache_TraceLineSurfaces(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NORMAL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT).fraction < 1)
return;
}
VectorScale(rtlight->currentcolor, cscale, color);
qglGenQueriesARB(r_maxqueries - i, r_queries + i);
CHECKGLERROR
}
- RSurf_ActiveWorldEntity();
+ RSurf_ActiveModelEntity(r_refdef.scene.worldentity, false, false, false);
GL_BlendFunc(GL_ONE, GL_ZERO);
GL_CullFace(GL_NONE);
GL_DepthMask(false);
if (rating >= 0.95)
{
rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
- if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1.0f)
+ if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1.0f)
{
bestrating = rating;
best = light;
vec3_t dest, endpos;
trace_t trace;
VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
- trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true);
+ trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
if (trace.fraction < 1)
{
dist = trace.fraction * r_editlights_cursordistance.value;
=============================================================================
*/
-void R_LightPoint(float *color, const vec3_t p, const int flags)
-{
- int i, numlights, flag;
- float f, relativepoint[3], dist, dist2, lightradius2;
- vec3_t diffuse, n;
- rtlight_t *light;
- dlight_t *dlight;
-
- if (r_fullbright.integer)
- {
- VectorSet(color, 1, 1, 1);
- return;
- }
-
- VectorClear(color);
-
- if (flags & LP_LIGHTMAP)
- {
- if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
- {
- VectorClear(diffuse);
- r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
- VectorAdd(color, diffuse, color);
- }
- else
- VectorSet(color, 1, 1, 1);
- color[0] += r_refdef.scene.ambient;
- color[1] += r_refdef.scene.ambient;
- color[2] += r_refdef.scene.ambient;
- }
-
- if (flags & LP_RTWORLD)
- {
- flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
- numlights = (int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
- for (i = 0; i < numlights; i++)
- {
- dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
- if (!dlight)
- continue;
- light = &dlight->rtlight;
- if (!(light->flags & flag))
- continue;
- // sample
- lightradius2 = light->radius * light->radius;
- VectorSubtract(light->shadoworigin, p, relativepoint);
- dist2 = VectorLength2(relativepoint);
- if (dist2 >= lightradius2)
- continue;
- dist = sqrt(dist2) / light->radius;
- f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
- if (f <= 0)
- continue;
- // todo: add to both ambient and diffuse
- if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
- VectorMA(color, f, light->currentcolor, color);
- }
- }
- if (flags & LP_DYNLIGHT)
- {
- // sample dlights
- for (i = 0;i < r_refdef.scene.numlights;i++)
- {
- light = r_refdef.scene.lights[i];
- // sample
- lightradius2 = light->radius * light->radius;
- VectorSubtract(light->shadoworigin, p, relativepoint);
- dist2 = VectorLength2(relativepoint);
- if (dist2 >= lightradius2)
- continue;
- dist = sqrt(dist2) / light->radius;
- f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
- if (f <= 0)
- continue;
- // todo: add to both ambient and diffuse
- if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction == 1)
- VectorMA(color, f, light->color, color);
- }
- }
-}
-
-void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
+void R_CompleteLightPoint(float *ambient, float *diffuse, float *lightdir, const vec3_t p, const int flags, float lightmapintensity, float ambientintensity)
{
- int i, numlights, flag;
+ int i, numlights, flag, q;
rtlight_t *light;
dlight_t *dlight;
float relativepoint[3];
float color[3];
- float dir[3];
float dist;
float dist2;
float intensity;
- float sample[5*3];
+ float sa[3], sx[3], sy[3], sz[3], sd[3];
float lightradius2;
- if (r_fullbright.integer)
- {
- VectorSet(ambient, 1, 1, 1);
- VectorClear(diffuse);
- VectorClear(lightdir);
- return;
- }
+ // use first order spherical harmonics to combine directional lights
+ for (q = 0; q < 3; q++)
+ sa[q] = sx[q] = sy[q] = sz[q] = sd[q] = 0;
- if (flags == LP_LIGHTMAP)
+ if (flags & LP_LIGHTMAP)
{
- VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
- VectorClear(diffuse);
- VectorClear(lightdir);
if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
- r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
+ {
+ float tempambient[3];
+ for (q = 0; q < 3; q++)
+ tempambient[q] = color[q] = relativepoint[q] = 0;
+ r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
+ // calculate a weighted average light direction as well
+ intensity = VectorLength(color);
+ for (q = 0; q < 3; q++)
+ {
+ sa[q] += (0.5f * color[q] + tempambient[q]) * lightmapintensity;
+ sx[q] += (relativepoint[0] * color[q]) * lightmapintensity;
+ sy[q] += (relativepoint[1] * color[q]) * lightmapintensity;
+ sz[q] += (relativepoint[2] * color[q]) * lightmapintensity;
+ sd[q] += (intensity * relativepoint[q]) * lightmapintensity;
+ }
+ }
else
- VectorSet(ambient, 1, 1, 1);
- return;
- }
-
- memset(sample, 0, sizeof(sample));
- VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
-
- if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
- {
- vec3_t tempambient;
- VectorClear(tempambient);
- VectorClear(color);
- VectorClear(relativepoint);
- r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
- VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
- VectorScale(color, r_refdef.lightmapintensity, color);
- VectorAdd(sample, tempambient, sample);
- VectorMA(sample , 0.5f , color, sample );
- VectorMA(sample + 3, relativepoint[0], color, sample + 3);
- VectorMA(sample + 6, relativepoint[1], color, sample + 6);
- VectorMA(sample + 9, relativepoint[2], color, sample + 9);
- // calculate a weighted average light direction as well
- intensity = VectorLength(color);
- VectorMA(sample + 12, intensity, relativepoint, sample + 12);
+ {
+ // unlit map - fullbright but scaled by lightmapintensity
+ for (q = 0; q < 3; q++)
+ sa[q] += lightmapintensity;
+ }
}
if (flags & LP_RTWORLD)
intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
if (intensity <= 0.0f)
continue;
- if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
continue;
- // scale down intensity to add to both ambient and diffuse
- //intensity *= 0.5f;
+ for (q = 0; q < 3; q++)
+ color[q] = light->currentcolor[q] * intensity;
+ intensity = VectorLength(color);
VectorNormalize(relativepoint);
- VectorScale(light->currentcolor, intensity, color);
- VectorMA(sample , 0.5f , color, sample );
- VectorMA(sample + 3, relativepoint[0], color, sample + 3);
- VectorMA(sample + 6, relativepoint[1], color, sample + 6);
- VectorMA(sample + 9, relativepoint[2], color, sample + 9);
- // calculate a weighted average light direction as well
- intensity *= VectorLength(color);
- VectorMA(sample + 12, intensity, relativepoint, sample + 12);
+ for (q = 0; q < 3; q++)
+ {
+ sa[q] += 0.5f * color[q];
+ sx[q] += relativepoint[0] * color[q];
+ sy[q] += relativepoint[1] * color[q];
+ sz[q] += relativepoint[2] * color[q];
+ sd[q] += intensity * relativepoint[q];
+ }
}
// FIXME: sample bouncegrid too!
}
intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
if (intensity <= 0.0f)
continue;
- if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
+ if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true).fraction < 1)
continue;
- // scale down intensity to add to both ambient and diffuse
- //intensity *= 0.5f;
+ for (q = 0; q < 3; q++)
+ color[q] = light->currentcolor[q] * intensity;
+ intensity = VectorLength(color);
VectorNormalize(relativepoint);
- VectorScale(light->currentcolor, intensity, color);
- VectorMA(sample , 0.5f , color, sample );
- VectorMA(sample + 3, relativepoint[0], color, sample + 3);
- VectorMA(sample + 6, relativepoint[1], color, sample + 6);
- VectorMA(sample + 9, relativepoint[2], color, sample + 9);
- // calculate a weighted average light direction as well
- intensity *= VectorLength(color);
- VectorMA(sample + 12, intensity, relativepoint, sample + 12);
+ for (q = 0; q < 3; q++)
+ {
+ sa[q] += 0.5f * color[q];
+ sx[q] += relativepoint[0] * color[q];
+ sy[q] += relativepoint[1] * color[q];
+ sz[q] += relativepoint[2] * color[q];
+ sd[q] += intensity * relativepoint[q];
+ }
}
}
- // calculate the direction we'll use to reduce the sample to a directional light source
- VectorCopy(sample + 12, dir);
- //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
- VectorNormalize(dir);
- // extract the diffuse color along the chosen direction and scale it
- diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
- diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
- diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
- // subtract some of diffuse from ambient
- VectorMA(sample, -0.333f, diffuse, ambient);
- // store the normalized lightdir
- VectorCopy(dir, lightdir);
+ // calculate the weighted-average light direction (bentnormal)
+ for (q = 0; q < 3; q++)
+ lightdir[q] = sd[q];
+ VectorNormalize(lightdir);
+ for (q = 0; q < 3; q++)
+ {
+ // extract the diffuse color along the chosen direction and scale it
+ diffuse[q] = (lightdir[0] * sx[q] + lightdir[1] * sy[q] + lightdir[2] * sz[q]);
+ // subtract some of diffuse from ambient
+ ambient[q] = sa[q] + -0.333f * diffuse[q] + ambientintensity;
+ }
}
projects / xonotic / darkplaces.git / blobdiff