Shadow cache fixes. SHADOW_TOLERANCE vs SMALL_TOLERANCE cleanup.

SHADOW_TOLERANCE not used for cached results leading to artifacts though
sometimes hiding others.

Shadow cache not invalidated on misses causing sometimes significant
performance hit.

SMALL_TOLERANCE being used instead of SHADOW_TOLERANCE in some trace shadow
related comparisons. Values had long (25+ years) been cleaned up ahead of
SMALL_TOLERANCE removal.

Note! This the last commit where SMALL_TOLERANCE will exist

Author: wfpokorny

source/core/configcore.h

@@ -182,9 +182,6 @@
 /// @def SMALL_TOLERANCE
 /// Minimum distance that qualifies as ray-object intersection.
 ///
-/// @note
-///     Some algorithms use @ref MIN_ISECT_DEPTH instead.
-///
 #define SMALL_TOLERANCE 0.001
 
 /// @def MAX_DISTANCE

source/core/math/polynomialsolver.h

@@ -59,14 +59,11 @@ class RenderStatistics;
 /// Maximum supported polynomial order.
 ///
 /// @todo
-///     This currently carries a large, fixed per polysolve() call
-///     memory allocation on the stack. Size is on the order of
-///     (MAX_ORDER+1)*int + PRECISE_FLOAT * (MAX_ORDER+1)^2
-///     which impacts performance and performance stability especially
-///     for threads > cores. Allocation based on current equation order
-///     would be better. My C++ attempts at this all badly slower. C itself
-///     supports a struct "flexible array member" feature, however this
-///     not a C++11 standard though some C++ compilers support it.
+///     This currently carries a large, fixed, per polysolve() call memory allocation
+///     on the stack. Size is on the order of (MAX_ORDER+1)*int + PRECISE_FLOAT *
+///     (MAX_ORDER+1)^2 which impacts performance and performance stability
+///     especially for threads > physical cores. Allocation based on current
+///     equation order would be better.
 ///
 #define MAX_ORDER 35
 

source/core/render/trace.cpp

@@ -1934,7 +1934,7 @@ struct NoShadowFlagRayObjectCondition : public RayObjectCondition
 
 struct SmallToleranceRayObjectCondition : public RayObjectCondition
 {
-    virtual bool operator()(const Ray&, ConstObjectPtr, double dist) const { return dist > SMALL_TOLERANCE; }
+    virtual bool operator()(const Ray&, ConstObjectPtr, double dist) const { return dist > SHADOW_TOLERANCE; }
 };
 
 void Trace::TracePointLightShadowRay(const LightSource &lightsource, double& lightsourcedepth, Ray& lightsourceray, MathColour& lightcolour)
@@ -1954,7 +1954,7 @@ void Trace::TracePointLightShadowRay(const LightSource &lightsource, double& lig
         if(FindIntersection(lightsource.Projected_Through_Object, tempIntersection, lightsourceray))
         {
             if((tempIntersection.Depth - lightsourcedepth) < 0.0)
-                projectedDepth = lightsourcedepth - fabs(tempIntersection.Depth) + SMALL_TOLERANCE;
+                projectedDepth = lightsourcedepth - fabs(tempIntersection.Depth) + SHADOW_TOLERANCE;
             else
             {
                 lightcolour.Clear();
@@ -1978,7 +1978,7 @@ void Trace::TracePointLightShadowRay(const LightSource &lightsource, double& lig
 
     // check for object in the light source shadow cache (object that fully shadowed during last test) first
 
-    if(lightsource.lightGroupLight == false) // we don't cache for light groups
+    if (lightsource.lightGroupLight == false) // we don't cache for light groups
     {
         if ((lightsourceray.GetTicket().traceLevel == 2) && (lightSourceLevel1ShadowCache[lightsource.index] != nullptr))
             cacheObject = lightSourceLevel1ShadowCache[lightsource.index];
@@ -1988,7 +1988,8 @@ void Trace::TracePointLightShadowRay(const LightSource &lightsource, double& lig
         // if there was an object in the light source shadow cache, check that first
         if (cacheObject != nullptr)
         {
-            if(FindIntersection(cacheObject, boundedIntersection, lightsourceray, lightsourcedepth - projectedDepth) == true)
+            if (FindIntersection(cacheObject, boundedIntersection, lightsourceray,
+                postcond, lightsourcedepth - projectedDepth) == true)
             {
                 if(!Test_Flag(boundedIntersection.Object, NO_SHADOW_FLAG))
                 {
@@ -2007,7 +2008,16 @@ void Trace::TracePointLightShadowRay(const LightSource &lightsource, double& lig
                     cacheObject = nullptr;
             }
             else
-                cacheObject = nullptr;
+            {
+                if (lightsourceray.GetTicket().traceLevel == 2)
+                {
+                    lightSourceLevel1ShadowCache[lightsource.index] = nullptr;
+                }
+                else
+                {
+                    lightSourceOtherShadowCache[lightsource.index] = nullptr;
+                }
+            }
         }
     }