[Bf-blender-cvs] [d1a9425a2fd] blender-v3.0-release: Fix T91733, T92486: Cycles wrong shadow catcher with volumes
Brecht Van Lommel
noreply at git.blender.org
Fri Nov 5 21:02:47 CET 2021
Commit: d1a9425a2fde32b6786b333ab55661da507e818b
Author: Brecht Van Lommel
Date: Wed Nov 3 17:28:12 2021 +0100
Branches: blender-v3.0-release
https://developer.blender.org/rBd1a9425a2fde32b6786b333ab55661da507e818b
Fix T91733, T92486: Cycles wrong shadow catcher with volumes
Changes:
* After hitting a shadow catcher, re-initialize the volume stack taking
into account shadow catcher ray visibility. This ensures that volume objects
are included in the stack only if they are shadow catchers.
* If there is a volume to be shaded in front of the shadow catcher, the split
is now performed in the shade_volume kernel after volume shading is done.
* Previously the background pass behind a shadow catcher was done as part of
the regular path, now it is done as part of the shadow catcher path.
For a shadow catcher path with volumes and visible background, operations are
done in this order now:
* intersect_closest
* shade_volume
* shadow catcher split
* intersect_volume_stack
* shade_background
* shade_surface
The world volume is currently assumed to be CG, that is it does not exist in
the footage. We may consider adding an option to control this, or change the
default. With a volume object this control is already possible.
This includes refactoring to centralize the logic for next kernel scheduling
in intersect_closest.h.
Differential Revision: https://developer.blender.org/D13093
===================================================================
M intern/cycles/kernel/integrator/intersect_closest.h
M intern/cycles/kernel/integrator/intersect_volume_stack.h
M intern/cycles/kernel/integrator/shade_background.h
M intern/cycles/kernel/integrator/shade_volume.h
M intern/cycles/kernel/integrator/shadow_catcher.h
M intern/cycles/kernel/integrator/state.h
M intern/cycles/kernel/integrator/state_util.h
===================================================================
diff --git a/intern/cycles/kernel/integrator/intersect_closest.h b/intern/cycles/kernel/integrator/intersect_closest.h
index 2cac18ed889..5522b46205b 100644
--- a/intern/cycles/kernel/integrator/intersect_closest.h
+++ b/intern/cycles/kernel/integrator/intersect_closest.h
@@ -31,7 +31,6 @@
CCL_NAMESPACE_BEGIN
-template<uint32_t current_kernel>
ccl_device_forceinline bool integrator_intersect_terminate(KernelGlobals kg,
IntegratorState state,
const int shader_flags)
@@ -86,36 +85,75 @@ ccl_device_forceinline bool integrator_intersect_terminate(KernelGlobals kg,
return false;
}
-/* Note that current_kernel is a template value since making this a variable
- * leads to poor performance with CUDA atomics. */
-template<uint32_t current_kernel>
-ccl_device_forceinline void integrator_intersect_shader_next_kernel(
- KernelGlobals kg,
- IntegratorState state,
- ccl_private const Intersection *ccl_restrict isect,
- const int shader,
- const int shader_flags)
+#ifdef __SHADOW_CATCHER__
+/* Split path if a shadow catcher was hit. */
+ccl_device_forceinline void integrator_split_shadow_catcher(
+ KernelGlobals kg, IntegratorState state, ccl_private const Intersection *ccl_restrict isect)
{
- /* Note on scheduling.
- *
- * When there is no shadow catcher split the scheduling is simple: schedule surface shading with
- * or without raytrace support, depending on the shader used.
- *
- * When there is a shadow catcher split the general idea is to have the following configuration:
- *
- * - Schedule surface shading kernel (with corresponding raytrace support) for the ray which
- * will trace shadow catcher object.
- *
- * - When no alpha-over of approximate shadow catcher is needed, schedule surface shading for
- * the matte ray.
- *
- * - Otherwise schedule background shading kernel, so that we have a background to alpha-over
- * on. The background kernel will then schedule surface shading for the matte ray.
+ /* Test if we hit a shadow catcher object, and potentially split the path to continue tracing two
+ * paths from here. */
+ const int object_flags = intersection_get_object_flags(kg, isect);
+ if (!kernel_shadow_catcher_is_path_split_bounce(kg, state, object_flags)) {
+ return;
+ }
+
+ /* Mark state as having done a shadow catcher split so that it stops contributing to
+ * the shadow catcher matte pass, but keeps contributing to the combined pass. */
+ INTEGRATOR_STATE_WRITE(state, path, flag) |= PATH_RAY_SHADOW_CATCHER_HIT;
+
+ /* Copy current state to new state. */
+ state = integrator_state_shadow_catcher_split(kg, state);
+
+ /* Initialize new state.
*
* Note that the splitting leaves kernel and sorting counters as-is, so use INIT semantic for
* the matte path. */
- const bool use_raytrace_kernel = (shader_flags & SD_HAS_RAYTRACE);
+ /* Mark current state so that it will only track contribution of shadow catcher objects ignoring
+ * non-catcher objects. */
+ INTEGRATOR_STATE_WRITE(state, path, flag) |= PATH_RAY_SHADOW_CATCHER_PASS;
+
+ if (kernel_data.film.pass_background != PASS_UNUSED && !kernel_data.background.transparent) {
+ /* If using background pass, schedule background shading kernel so that we have a background
+ * to alpha-over on. The background kernel will then continue the path afterwards. */
+ INTEGRATOR_STATE_WRITE(state, path, flag) |= PATH_RAY_SHADOW_CATCHER_BACKGROUND;
+ INTEGRATOR_PATH_INIT(DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND);
+ return;
+ }
+
+ if (!integrator_state_volume_stack_is_empty(kg, state)) {
+ /* Volume stack is not empty. Re-init the volume stack to exclude any non-shadow catcher
+ * objects from it, and then continue shading volume and shadow catcher surface after. */
+ INTEGRATOR_PATH_INIT(DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK);
+ return;
+ }
+
+ /* Continue with shading shadow catcher surface. */
+ const int shader = intersection_get_shader(kg, isect);
+ const int flags = kernel_tex_fetch(__shaders, shader).flags;
+ const bool use_raytrace_kernel = (flags & SD_HAS_RAYTRACE);
+
+ if (use_raytrace_kernel) {
+ INTEGRATOR_PATH_INIT_SORTED(DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE, shader);
+ }
+ else {
+ INTEGRATOR_PATH_INIT_SORTED(DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE, shader);
+ }
+}
+
+/* Schedule next kernel to be executed after updating volume stack for shadow catcher. */
+template<uint32_t current_kernel>
+ccl_device_forceinline void integrator_intersect_next_kernel_after_shadow_catcher_volume(
+ KernelGlobals kg, IntegratorState state)
+{
+ /* Continue with shading shadow catcher surface. Same as integrator_split_shadow_catcher, but
+ * using NEXT instead of INIT. */
+ Intersection isect ccl_optional_struct_init;
+ integrator_state_read_isect(kg, state, &isect);
+
+ const int shader = intersection_get_shader(kg, &isect);
+ const int flags = kernel_tex_fetch(__shaders, shader).flags;
+ const bool use_raytrace_kernel = (flags & SD_HAS_RAYTRACE);
if (use_raytrace_kernel) {
INTEGRATOR_PATH_NEXT_SORTED(
@@ -124,23 +162,132 @@ ccl_device_forceinline void integrator_intersect_shader_next_kernel(
else {
INTEGRATOR_PATH_NEXT_SORTED(current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE, shader);
}
+}
-#ifdef __SHADOW_CATCHER__
- const int object_flags = intersection_get_object_flags(kg, isect);
- if (kernel_shadow_catcher_split(kg, state, object_flags)) {
- if (kernel_data.film.pass_background != PASS_UNUSED && !kernel_data.background.transparent) {
- INTEGRATOR_STATE_WRITE(state, path, flag) |= PATH_RAY_SHADOW_CATCHER_BACKGROUND;
+/* Schedule next kernel to be executed after executing background shader for shadow catcher. */
+template<uint32_t current_kernel>
+ccl_device_forceinline void integrator_intersect_next_kernel_after_shadow_catcher_background(
+ KernelGlobals kg, IntegratorState state)
+{
+ /* Same logic as integrator_split_shadow_catcher, but using NEXT instead of INIT. */
+ if (!integrator_state_volume_stack_is_empty(kg, state)) {
+ /* Volume stack is not empty. Re-init the volume stack to exclude any non-shadow catcher
+ * objects from it, and then continue shading volume and shadow catcher surface after. */
+ INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK);
+ return;
+ }
+
+ /* Continue with shading shadow catcher surface. */
+ integrator_intersect_next_kernel_after_shadow_catcher_volume<current_kernel>(kg, state);
+}
+#endif
- INTEGRATOR_PATH_INIT(DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND);
+/* Schedule next kernel to be executed after intersect closest.
+ *
+ * Note that current_kernel is a template value since making this a variable
+ * leads to poor performance with CUDA atomics. */
+template<uint32_t current_kernel>
+ccl_device_forceinline void integrator_intersect_next_kernel(
+ KernelGlobals kg,
+ IntegratorState state,
+ ccl_private const Intersection *ccl_restrict isect,
+ const bool hit)
+{
+ /* Continue with volume kernel if we are inside a volume, regardless if we hit anything. */
+#ifdef __VOLUME__
+ if (!integrator_state_volume_stack_is_empty(kg, state)) {
+ const bool hit_surface = hit && !(isect->type & PRIMITIVE_LAMP);
+ const int shader = (hit_surface) ? intersection_get_shader(kg, isect) : SHADER_NONE;
+ const int flags = (hit_surface) ? kernel_tex_fetch(__shaders, shader).flags : 0;
+
+ if (!integrator_intersect_terminate(kg, state, flags)) {
+ INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME);
}
- else if (use_raytrace_kernel) {
- INTEGRATOR_PATH_INIT_SORTED(DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE, shader);
+ else {
+ INTEGRATOR_PATH_TERMINATE(current_kernel);
+ }
+ return;
+ }
+#endif
+
+ if (hit) {
+ /* Hit a surface, continue with light or surface kernel. */
+ if (isect->type & PRIMITIVE_LAMP) {
+ INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT);
}
else {
- INTEGRATOR_PATH_INIT_SORTED(DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE, shader);
+ /* Hit a surface, continue with surface kernel unless terminated. */
+ const int shader = intersection_get_shader(kg, isect);
+ const int flags = kernel_tex_fetch(__shaders, shader).flags;
+
+ if (!integrator_intersect_terminate(kg, state, flags)) {
+ const bool use_raytrace_kernel = (flags & SD_HAS_RAYTRACE);
+ if (use_raytrace_kernel) {
+ INTEGRATOR_PATH_NEXT_SORTED(
+ current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE, shader);
+ }
+ else {
+ INTEGRATOR_PATH_NEXT_SORTED(
+ current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE, shader);
+ }
+
+#ifdef __SHADOW_CATCHER__
+ /* Handle shadow catcher. */
+ integrator_split_shadow_catcher(kg, state, isect);
+#endif
+ }
+ else {
+ INTEGRATOR_PATH_TERMINATE(current_kernel);
+ }
}
}
+ else {
+ /* Nothing hit, continue with background kernel. */
+ INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND);
+ }
+}
+
+/* Schedule next kernel to be executed after shade volume.
+ *
+ * The logic here matches integrator_intersect_next_kernel, except that
+ * volume shading and termination testing have already been done. */
+template<uint32_t current_kernel>
+ccl_device_forceinline void integrator_intersect_next_kernel_after_volume(
+ KernelGlobals kg, IntegratorState state, ccl_private const Intersection *ccl_restrict isect)
+{
+ if (isect->prim != PRIM_NONE) {
+ /* Hit a surface, continue with light or surface kernel. */
+ if (isect->type & PRIMITIVE_LAMP) {
+ INTEGRATOR_PATH_NEXT(current_kernel, DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT);
+ return;
+ }
+ else {
+ /* Hit a surface, continue with surface kernel unless terminated. */
+ const int shader = intersection_get_shader(kg, isect);
+ const int flags = kernel_tex_fetch(__shaders, shader).flags;
+
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list