Merge branch 'AcademySoftwareFoundation:main' into add-testrender-volumes

Author: ThyOwen

.github/workflows/ci.yml

@@ -475,7 +475,7 @@ jobs:
                             PUGIXML_VERSION=v1.15
                             FREETYPE_VERSION=VER-2-14-3
           - desc: clang14/C++17 llvm14 py3.10 avx2 batch-b16avx512
-            nametag: linux-latest-releases-clang
+            nametag: linux-clang14
             runner: ubuntu-22.04
             cxx_compiler: clang++
             cc_compiler: clang

Testing/Temporary/CTestCostData.txt

@@ -2050,7 +2050,7 @@ process_bsdf_closure(const ShaderGlobalsType& sg, float path_roughness,
                         }
                     }
                     break;
-                }
+                };
                 case MX_TRANSLUCENT_ID: {
                     const MxTranslucentParams* srcparams
                         = comp->as<MxTranslucentParams>();

src/testrender/shading.cpp

@@ -368,13 +368,6 @@ struct BSDF : public AbstractBSDF {
 #endif
 };
 
-template<typename, typename = void> struct has_equal : std::false_type {};
-
-template<typename T>
-struct has_equal<T, std::void_t<decltype(std::declval<const T&>()
-                                         == std::declval<const T&>())>>
-    : std::true_type {};
-
 struct Medium : public AbstractMedium {
     struct Sample {
         OSL_HOSTDEVICE Sample() : t(0.0f), transmittance(0.0f), weight(0.0f) {}
@@ -471,7 +464,7 @@ struct CompositeBSDF {
 
     OSL_HOSTDEVICE BSDF::Sample eval(const Vec3& wo, const Vec3& wi) const
     {
-        BSDF::Sample s;  // Use default constructor instead of {} initialization
+        BSDF::Sample s {};
         for (int i = 0; i < num_bsdfs; i++) {
             BSDF::Sample b = bsdfs[i]->eval_vrtl(wo, wi);
             b.weight *= weights[i];

src/testrender/shading.h

@@ -968,14 +968,14 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
     Color3 path_radiance(0, 0, 0);
     int prev_id    = -1;
     float bsdf_pdf = inf;  // camera ray has only one possible direction
-
     MediumStack medium_stack;
 
+
     for (int b = 0; b <= max_bounces; b++) {
         ShaderGlobalsType sg;
+
         // trace the ray against the scene
         Intersection hit = scene.intersect(r, inf, prev_id);
-
         if (hit.t == inf) {
             // we hit nothing? check background shader
             if (backgroundShaderID >= 0) {
@@ -994,9 +994,8 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
             }
             break;
         }
-
-        if (medium_stack.integrate(r, sampler, hit, path_weight, path_radiance,
-                                   bsdf_pdf)) {
+        
+        if (medium_stack.integrate(r, sampler, hit, path_weight, path_radiance, bsdf_pdf)) {
             continue;
         }
 
@@ -1026,9 +1025,8 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         int shaderID = scene.shaderid(hit.id);
 
 #ifndef __CUDACC__
-        if (shaderID < 0 || !m_shaders[shaderID].surf) {
+        if (shaderID < 0 || !m_shaders[shaderID].surf)
             break;  // no shader attached? done
-        }
 
         // execute shader and process the resulting list of closures
         shadingsys->execute(*ctx, *m_shaders[shaderID].surf, sg);
@@ -1094,7 +1092,6 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
                                               Ray::SHADOW);
                 Intersection shadow_hit = scene.intersect(shadow_ray, inf,
                                                           hit.id);
-
                 if (shadow_hit.t == inf)  // ray reached the background?
                     path_radiance += contrib;
             }
@@ -1124,30 +1121,37 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
                     Ray shadow_ray = Ray(sg.P, sample.dir, radius, 0, 0,
                                          Ray::SHADOW);
                     // trace a shadow ray and see if we actually hit the target
+                    // in this tiny renderer, tracing a ray is probably cheaper than evaluating the light shader
                     Intersection shadow_hit
                         = scene.intersect(shadow_ray, sample.dist, hit.id, lid);
 
 #ifndef __CUDACC__
                     const bool did_hit = shadow_hit.t == sample.dist;
 #else
+                    // The hit distance on the device is not as precise as on
+                    // the CPU, so we need to allow a little wiggle room. An
+                    // epsilon of 1e-3f empirically gives results that closely
+                    // match the CPU for the test scenes, so that's what we're
+                    // using.
                     const bool did_hit = fabsf(shadow_hit.t - sample.dist)
                                          < 1e-3f;
 #endif
-
                     if (did_hit) {
+                        // setup a shader global for the point on the light
                         globals_from_hit(light_sg, shadow_ray, sample.dist, lid,
                                          sample.u, sample.v);
 #ifndef __CUDACC__
+                        // execute the light shader (for emissive closures only)
                         shadingsys->execute(*ctx, *m_shaders[shaderID].surf,
                                             light_sg);
 #else
                         execute_shader(light_sg, shaderID, light_closure_pool);
 #endif
                         ShadingResult light_result;
                         process_closure(light_sg, r.roughness, light_result,
-                                        medium_stack,
-                                        (const ClosureColor*)light_sg.Ci, true);
-
+                                        medium_stack, (const ClosureColor*)light_sg.Ci, 
+                                        true);
+                        // accumulate contribution
                         path_radiance += contrib * light_result.Le;
                     }
                 }
@@ -1164,13 +1168,13 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
         // Just simply use roughness as spread slope
         r.spread    = std::max(r.spread, p.roughness);
         r.roughness = p.roughness;
-
+        
         if (sg.backfacing) {  // if exiting
             medium_stack.pop_medium();
         }
-
-        if (!(path_weight.x > 0) && !(path_weight.y > 0) && !(path_weight.z > 0)
-            && b > 10)
+        
+        if (!(path_weight.x > 0) && !(path_weight.y > 0)
+            && !(path_weight.z > 0) && b > 10)
             break;  // filter out all 0's or NaNs
         prev_id  = hit.id;
         r.origin = sg.P;
@@ -1179,6 +1183,7 @@ SimpleRaytracer::subpixel_radiance(float x, float y, Sampler& sampler,
 }
 
 
+
 OSL_HOSTDEVICE Color3
 SimpleRaytracer::antialias_pixel(int x, int y, ShadingContext* ctx)
 {

src/testrender/simpleraytracer.cpp

@@ -78,13 +78,24 @@ def make_relpath (path, start=os.curdir):
 command = ""
 outputs = [ "out.txt" ]    # default
 
-# Control image differencing
+# The image comparison thresholds are tricky to remember. Here's the key:
+# A test fails if more than `failpercent` of pixel values differ by more
+# than `failthresh` AND the difference is more than `failrelative` times the
+# correct pixel value, or if even one pixel differs by more than `hardfail`.
+failthresh = 0.004         # "Failure" threshold for any pixel value
+hardfail = 0.01            # Even one pixel this wrong => hard failure
+failpercent = 0.02         # Ok fo this percentage of pixels to "fail"
+failrelative = 0.001       # Ok to fail up to this amount vs the pixel value
+allowfailures = 0          # Freebie failures
+
+# Some tests are designed for the app running to "fail" (in the sense of
+# terminating with an error return code), for example, a test that is designed
+# to present an error condition to check that it issues the right error. That
+# "failure" is a success of the test! For those cases, set `failureok = 1` to
+# indicate that the app having an error is fine, and the full test will pass
+# or fail based on comparing the output files.
 failureok = 0
-failthresh = 0.004
-hardfail = 0.01
-failpercent = 0.02
-failrelative = 0.001
-allowfailures = 0
+
 idiff_program = "oiiotool"
 idiff_postfilecmd = ""
 skip_diff = int(os.environ.get("OSL_TESTSUITE_SKIP_DIFF", "0"))