Merge remote-tracking branch 'b/main'

Author: youle31

CMakeLists.txt

@@ -881,6 +881,14 @@ else()
   set(WITH_LINUX_OFFICIAL_RELEASE_TESTS OFF)
 endif()
 
+option(WITH_TESTS_EXPERIMENTAL "\
+Run tests marked as experimental. \
+These tests are labeled as such due to long runtime, flakey results, or other issues that make them unsuitable \
+for blocking a build on."
+  OFF
+)
+mark_as_advanced(WITH_TESTS_EXPERIMENTAL)
+
 # Enabled by default for typical use cases to speed up development cycles. However, when looking
 # into threading or memory related issues (in dependency graph, out-of-bounds, etc) forcing single
 # test per Blender instance could give much better clues about the root of the problem.

build_files/cmake/platform/platform_apple.cmake

@@ -374,7 +374,7 @@ endif()
 if(WITH_HARU)
   find_package(Haru REQUIRED)
 endif()
- 
+
 if(WITH_MANIFOLD)
   find_package(manifold REQUIRED)
 endif()

extern/CMakeLists.txt

@@ -7,7 +7,7 @@ add_subdirectory(curve_fit_nd)
 add_subdirectory(fmtlib)
 if(WITH_IO_FBX)
   add_subdirectory(ufbx)
-endif()  
+endif()
 
 # Otherwise we get warnings here that we cant fix in external projects
 remove_strict_flags()

intern/cycles/blender/object.cpp

@@ -311,9 +311,9 @@ Object *BlenderSync::sync_object(BL::ViewLayer &b_view_layer,
   /* object sync
    * transform comparison should not be needed, but duplis don't work perfect
    * in the depsgraph and may not signal changes, so this is a workaround */
-  if (object->is_modified() || object_updated ||
-      (object->get_geometry() && object->get_geometry()->is_modified()))
-  {
+  const bool do_sync = object->is_modified() || object_updated ||
+                       (object->get_geometry() && object->get_geometry()->is_modified());
+  if (do_sync) {
     object->name = b_ob.name().c_str();
     object->set_pass_id(b_ob.pass_index());
     const BL::Array<float, 4> object_color = b_ob.color();
@@ -345,12 +345,14 @@ Object *BlenderSync::sync_object(BL::ViewLayer &b_view_layer,
     object->set_receiver_light_set(BlenderLightLink::get_receiver_light_set(b_parent, b_ob));
     object->set_shadow_set_membership(BlenderLightLink::get_shadow_set_membership(b_parent, b_ob));
     object->set_blocker_shadow_set(BlenderLightLink::get_blocker_shadow_set(b_parent, b_ob));
-
-    object->tag_update(scene);
   }
 
   sync_object_motion_init(b_parent, b_ob, object);
 
+  if (do_sync || object->motion_is_modified()) {
+    object->tag_update(scene);
+  }
+
   if (is_instance) {
     /* Sync possible particle data. */
     sync_dupli_particle(b_parent, b_instance, object);

intern/cycles/integrator/denoiser_gpu.cpp

@@ -259,6 +259,12 @@ bool DenoiserGPU::denoise_filter_color_postprocess(const DenoiseContext &context
 bool DenoiserGPU::denoise_filter_color_preprocess(const DenoiseContext &context,
                                                   const DenoisePass &pass)
 {
+  if (context.denoise_params.type != DENOISER_OPTIX) {
+    /* Pass preprocessing is used to clamp values for the OptiX denoiser.
+     * Clamping is not necceasry for other denoisers, so just skip this preprocess step. */
+    return true;
+  }
+
   const BufferParams &buffer_params = context.buffer_params;
 
   const int work_size = buffer_params.width * buffer_params.height;

intern/cycles/kernel/bvh/bvh.h

@@ -229,7 +229,7 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals kg,
                                                      IntegratorShadowState state,
                                                      const ccl_private Ray *ray,
                                                      const uint visibility,
-                                                     const uint max_hits,
+                                                     const uint max_transparent_hits,
                                                      ccl_private uint *num_recorded_hits,
                                                      ccl_private float *throughput)
 {
@@ -244,7 +244,7 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals kg,
   {
     if (kernel_data.device_bvh) {
       return kernel_embree_intersect_shadow_all(
-          kg, state, ray, visibility, max_hits, num_recorded_hits, throughput);
+          kg, state, ray, visibility, max_transparent_hits, num_recorded_hits, throughput);
     }
   }
 #    endif
@@ -256,24 +256,24 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals kg,
 #      ifdef __HAIR__
       if (kernel_data.bvh.have_curves) {
         return bvh_intersect_shadow_all_hair_motion(
-            kg, ray, state, visibility, max_hits, num_recorded_hits, throughput);
+            kg, ray, state, visibility, max_transparent_hits, num_recorded_hits, throughput);
       }
 #      endif /* __HAIR__ */
 
       return bvh_intersect_shadow_all_motion(
-          kg, ray, state, visibility, max_hits, num_recorded_hits, throughput);
+          kg, ray, state, visibility, max_transparent_hits, num_recorded_hits, throughput);
     }
 #    endif /* __OBJECT_MOTION__ */
 
 #    ifdef __HAIR__
     if (kernel_data.bvh.have_curves) {
       return bvh_intersect_shadow_all_hair(
-          kg, ray, state, visibility, max_hits, num_recorded_hits, throughput);
+          kg, ray, state, visibility, max_transparent_hits, num_recorded_hits, throughput);
     }
 #    endif /* __HAIR__ */
 
     return bvh_intersect_shadow_all(
-        kg, ray, state, visibility, max_hits, num_recorded_hits, throughput);
+        kg, ray, state, visibility, max_transparent_hits, num_recorded_hits, throughput);
   }
 
   kernel_assert(false);

intern/cycles/kernel/bvh/shadow_all.h

@@ -31,7 +31,7 @@ ccl_device_inline
                                 const ccl_private Ray *ray,
                                 IntegratorShadowState state,
                                 const uint visibility,
-                                const uint max_hits,
+                                const uint max_transparent_hits,
                                 ccl_private uint *r_num_recorded_hits,
                                 ccl_private float *r_throughput)
 {
@@ -54,7 +54,7 @@ ccl_device_inline
   float3 idir = bvh_inverse_direction(dir);
   float tmin = ray->tmin;
   int object = OBJECT_NONE;
-  uint num_hits = 0;
+  uint num_transparent_hits = 0;
 
   /* Max distance in world space. May be dynamically reduced when max number of
    * recorded hits is exceeded and we no longer need to find hits beyond the max
@@ -241,8 +241,9 @@ ccl_device_inline
                 continue;
               }
 
-              num_hits++;
-              if (num_hits > max_hits) {
+              /* Only count transparent bounces, volume bounds bounces are counted when shading. */
+              num_transparent_hits += !(flags & SD_HAS_ONLY_VOLUME);
+              if (num_transparent_hits > max_transparent_hits) {
                 return true;
               }
 
@@ -268,7 +269,7 @@ ccl_device_inline
                  * so that we can detect this and trace another ray if needed. */
                 ++(*r_num_recorded_hits);
 
-                const uint max_record_hits = min(max_hits, (uint)INTEGRATOR_SHADOW_ISECT_SIZE);
+                const uint max_record_hits = (uint)INTEGRATOR_SHADOW_ISECT_SIZE;
                 if (*r_num_recorded_hits <= max_record_hits || isect.t < tmax_hits) {
                   integrator_state_write_shadow_isect(state, &isect, isect_index);
 
@@ -331,12 +332,12 @@ ccl_device_inline bool BVH_FUNCTION_NAME(KernelGlobals kg,
                                          const ccl_private Ray *ray,
                                          IntegratorShadowState state,
                                          const uint visibility,
-                                         const uint max_hits,
+                                         const uint max_transparent_hits,
                                          ccl_private uint *num_recorded_hits,
                                          ccl_private float *throughput)
 {
   return BVH_FUNCTION_FULL_NAME(BVH)(
-      kg, ray, state, visibility, max_hits, num_recorded_hits, throughput);
+      kg, ray, state, visibility, max_transparent_hits, num_recorded_hits, throughput);
 }
 
 #undef BVH_FUNCTION_NAME

intern/cycles/kernel/device/cpu/bvh.h

@@ -80,8 +80,8 @@ struct CCLShadowContext
   float throughput;
   float max_t;
   bool opaque_hit;
-  numhit_t max_hits;
-  numhit_t num_hits;
+  numhit_t max_transparent_hits;
+  numhit_t num_transparent_hits;
   numhit_t num_recorded_hits;
 };
 
@@ -343,22 +343,24 @@ ccl_device_forceinline void kernel_embree_filter_occluded_shadow_all_func_impl(
   }
 #endif
 
-  /* If no transparent shadows or max number of hits exceeded, all light is blocked. */
+  /* If no transparent shadows, all light is blocked. */
   const int flags = intersection_get_shader_flags(kg, current_isect.prim, current_isect.type);
   if ((flags & SD_HAS_TRANSPARENT_SHADOW) == 0) {
     ctx->opaque_hit = true;
     return;
   }
 
   if (intersection_skip_shadow_already_recoded(
-          kg, ctx->isect_s, current_isect.object, current_isect.prim, ctx->num_hits))
+          kg, ctx->isect_s, current_isect.object, current_isect.prim, ctx->num_recorded_hits))
   {
     *args->valid = 0;
     return;
   }
 
-  ++ctx->num_hits;
-  if (ctx->num_hits > ctx->max_hits) {
+  /* Only count transparent bounces, volume bounds bounces are counted during shading. */
+  ctx->num_transparent_hits += !(flags & SD_HAS_ONLY_VOLUME);
+  if (ctx->num_transparent_hits > ctx->max_transparent_hits) {
+    /* Max number of hits exceeded. */
     ctx->opaque_hit = true;
     return;
   }
@@ -390,7 +392,7 @@ ccl_device_forceinline void kernel_embree_filter_occluded_shadow_all_func_impl(
   /* This tells Embree to continue tracing. */
   *args->valid = 0;
 
-  const numhit_t max_record_hits = min(ctx->max_hits, numhit_t(INTEGRATOR_SHADOW_ISECT_SIZE));
+  const numhit_t max_record_hits = numhit_t(INTEGRATOR_SHADOW_ISECT_SIZE);
   /* If the maximum number of hits was reached, replace the furthest intersection
    * with a closer one so we get the N closest intersections. */
   if (isect_index >= max_record_hits) {
@@ -862,7 +864,7 @@ ccl_device_intersect bool kernel_embree_intersect_shadow_all(KernelGlobals kg,
                                                              IntegratorShadowState state,
                                                              const ccl_private Ray *ray,
                                                              const uint visibility,
-                                                             const uint max_hits,
+                                                             const uint max_transparent_hits,
                                                              ccl_private uint *num_recorded_hits,
                                                              ccl_private float *throughput)
 {
@@ -882,11 +884,11 @@ ccl_device_intersect bool kernel_embree_intersect_shadow_all(KernelGlobals kg,
   CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_SHADOW_ALL);
   rtcInitIntersectContext(&ctx);
 #  endif
-  ctx.num_hits = ctx.num_recorded_hits = numhit_t(0);
+  ctx.num_transparent_hits = ctx.num_recorded_hits = numhit_t(0);
   ctx.throughput = 1.0f;
   ctx.opaque_hit = false;
   ctx.isect_s = state;
-  ctx.max_hits = numhit_t(max_hits);
+  ctx.max_transparent_hits = numhit_t(max_transparent_hits);
   ctx.max_t = ray->tmax;
   ctx.ray = ray;
   RTCRay rtc_ray;

intern/cycles/kernel/device/hiprt/bvh.h

@@ -166,7 +166,7 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals kg,
                                                      IntegratorShadowState state,
                                                      const ccl_private Ray *ray,
                                                      const uint visibility,
-                                                     const uint max_hits,
+                                                     const uint max_transparent_hits,
                                                      ccl_private uint *num_recorded_hits,
                                                      ccl_private float *throughput)
 {
@@ -187,8 +187,8 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals kg,
   payload.prim_type = PRIMITIVE_NONE;
   payload.ray_time = ray->time;
   payload.in_state = state;
-  payload.max_hits = max_hits;
-  payload.num_hits = 0;
+  payload.max_transparent_hits = max_transparent_hits;
+  payload.num_transparent_hits = 0;
   payload.r_num_recorded_hits = num_recorded_hits;
   payload.r_throughput = throughput;
 

intern/cycles/kernel/device/hiprt/common.h

@@ -19,8 +19,8 @@ struct RayPayload {
  * NOTE: This assumes that reinterpret_cast from void pointer to RayPayload works correctly. */
 struct ShadowPayload : RayPayload {
   int in_state;
-  uint max_hits;
-  uint num_hits;
+  uint max_transparent_hits;
+  uint num_transparent_hits;
   uint *r_num_recorded_hits;
   float *r_throughput;
 };
@@ -380,8 +380,8 @@ ccl_device_inline bool shadow_intersection_filter(const hiprtRay &ray,
 {
   KernelGlobals kg = payload->kg;
 
-  const uint num_hits = payload->num_hits;
-  const uint max_hits = payload->max_hits;
+  uint num_transparent_hits = payload->num_transparent_hits;
+  const uint max_transparent_hits = payload->max_transparent_hits;
   const int state = payload->in_state;
   const RaySelfPrimitives &self = payload->self;
 
@@ -407,7 +407,9 @@ ccl_device_inline bool shadow_intersection_filter(const hiprtRay &ray,
     return true; /* No hit -continue traversal. */
   }
 
-  if (intersection_skip_shadow_already_recoded(kg, state, object, prim, num_hits)) {
+  if (intersection_skip_shadow_already_recoded(
+          kg, state, object, prim, *payload->r_num_recorded_hits))
+  {
     return true;
   }
 
@@ -418,18 +420,22 @@ ccl_device_inline bool shadow_intersection_filter(const hiprtRay &ray,
 #  ifndef __TRANSPARENT_SHADOWS__
   return false;
 #  else
-  if (num_hits >= max_hits ||
-      !(intersection_get_shader_flags(kg, prim, primitive_type) & SD_HAS_TRANSPARENT_SHADOW))
-  {
+  const int flags = intersection_get_shader_flags(kg, prim, primitive_type);
+  if (!(flags & SD_HAS_TRANSPARENT_SHADOW)) {
+    return false;
+  }
+
+  num_transparent_hits += !(flags & SD_HAS_ONLY_VOLUME);
+  if (num_transparent_hits > max_transparent_hits) {
     return false;
   }
 
   uint record_index = *payload->r_num_recorded_hits;
 
-  payload->num_hits = num_hits + 1;
+  payload->num_transparent_hits = num_transparent_hits;
   *(payload->r_num_recorded_hits) += 1;
 
-  const uint max_record_hits = min(max_hits, INTEGRATOR_SHADOW_ISECT_SIZE);
+  const uint max_record_hits = INTEGRATOR_SHADOW_ISECT_SIZE;
   if (record_index >= max_record_hits) {
     float max_recorded_t = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 0, t);
     uint max_recorded_hit = 0;
@@ -467,9 +473,9 @@ ccl_device_inline bool shadow_intersection_filter_curves(const hiprtRay &ray,
 {
   KernelGlobals kg = payload->kg;
 
-  const uint num_hits = payload->num_hits;
+  uint num_transparent_hits = payload->num_transparent_hits;
   const uint num_recorded_hits = *(payload->r_num_recorded_hits);
-  const uint max_hits = payload->max_hits;
+  const uint max_transparent_hits = payload->max_transparent_hits;
   const RaySelfPrimitives &self = payload->self;
 
   const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
@@ -494,7 +500,10 @@ ccl_device_inline bool shadow_intersection_filter_curves(const hiprtRay &ray,
     return true; /* No hit -continue traversal. */
   }
 
-  if (intersection_skip_shadow_already_recoded(kg, payload->in_state, object, prim, num_hits)) {
+  /* FIXME: transparent curves are not recorded, this check doesn't work. */
+  if (intersection_skip_shadow_already_recoded(
+          kg, payload->in_state, object, prim, num_recorded_hits))
+  {
     return true;
   }
 
@@ -510,16 +519,20 @@ ccl_device_inline bool shadow_intersection_filter_curves(const hiprtRay &ray,
 #  ifndef __TRANSPARENT_SHADOWS__
   return false;
 #  else
-  if (num_hits >= max_hits ||
-      !(intersection_get_shader_flags(kg, prim, primitive_type) & SD_HAS_TRANSPARENT_SHADOW))
-  {
+  const int flags = intersection_get_shader_flags(kg, prim, primitive_type);
+  if (!(flags & SD_HAS_TRANSPARENT_SHADOW)) {
+    return false;
+  }
+
+  num_transparent_hits += !(flags & SD_HAS_ONLY_VOLUME);
+  if (num_transparent_hits > max_transparent_hits) {
     return false;
   }
 
   float throughput = *payload->r_throughput;
   throughput *= intersection_curve_shadow_transparency(kg, object, prim, primitive_type, u);
   *payload->r_throughput = throughput;
-  payload->num_hits += 1;
+  payload->num_transparent_hits = num_transparent_hits;
 
   if (throughput < CURVE_SHADOW_TRANSPARENCY_CUTOFF) {
     return false;