@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/integrator/intersect_shadow.h

@@ -1,183 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/globals.h"
-#include "kernel/types.h"
-
-#include "kernel/bvh/bvh.h"
-
-#include "kernel/integrator/state.h"
-#include "kernel/integrator/state_flow.h"
-#include "kernel/integrator/state_util.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Visibility for the shadow ray. */
-ccl_device_forceinline uint integrate_intersect_shadow_visibility(ConstIntegratorShadowState state)
-{
-  uint visibility = PATH_RAY_SHADOW;
-
-#ifdef __SHADOW_CATCHER__
-  const uint32_t path_flag = INTEGRATOR_STATE(state, shadow_path, flag);
-  visibility = SHADOW_CATCHER_PATH_VISIBILITY(path_flag, visibility);
-#endif
-
-  return visibility;
-}
-
-ccl_device bool integrate_intersect_shadow_opaque(KernelGlobals kg,
-                                                  IntegratorShadowState state,
-                                                  const ccl_private Ray *ray,
-                                                  const uint visibility)
-{
-  /* Mask which will pick only opaque visibility bits from the `visibility`.
-   * Calculate the mask at compile time: the visibility will either be a high bits for the shadow
-   * catcher objects, or lower bits for the regular objects (there is no need to check the path
-   * state here again). */
-  constexpr const uint opaque_mask = SHADOW_CATCHER_VISIBILITY_SHIFT(PATH_RAY_SHADOW_OPAQUE) |
-                                     PATH_RAY_SHADOW_OPAQUE;
-
-  const bool opaque_hit = scene_intersect_shadow(kg, ray, visibility & opaque_mask);
-
-  /* Only record the number of hits if nothing was hit, so that the shadow shading kernel does not
-   * consider any intersections. There is no need to write anything to the state if the hit is
-   * opaque because in this case the path is terminated. */
-  if (!opaque_hit) {
-    INTEGRATOR_STATE_WRITE(state, shadow_path, num_hits) = 0;
-  }
-
-  return opaque_hit;
-}
-
-ccl_device_forceinline int integrate_shadow_max_transparent_hits(KernelGlobals kg,
-                                                                 ConstIntegratorShadowState state)
-{
-  const int transparent_max_bounce = kernel_data.integrator.transparent_max_bounce;
-  const int transparent_bounce = INTEGRATOR_STATE(state, shadow_path, transparent_bounce);
-
-  return max(transparent_max_bounce - transparent_bounce, 0);
-}
-
-#ifdef __TRANSPARENT_SHADOWS__
-#  ifndef __KERNEL_GPU__
-ccl_device int shadow_intersections_compare(const void *a, const void *b)
-{
-  const Intersection *isect_a = (const Intersection *)a;
-  const Intersection *isect_b = (const Intersection *)b;
-
-  if (isect_a->t < isect_b->t) {
-    return -1;
-  }
-  if (isect_a->t > isect_b->t) {
-    return 1;
-  }
-  return 0;
-}
-#  endif
-
-ccl_device_inline void sort_shadow_intersections(IntegratorShadowState state, uint num_hits)
-{
-  kernel_assert(num_hits > 0);
-
-#  ifdef __KERNEL_GPU__
-  /* Use bubble sort which has more friendly memory pattern on GPU. */
-  bool swapped;
-  do {
-    swapped = false;
-    for (int j = 0; j < num_hits - 1; ++j) {
-      if (INTEGRATOR_STATE_ARRAY(state, shadow_isect, j, t) >
-          INTEGRATOR_STATE_ARRAY(state, shadow_isect, j + 1, t))
-      {
-        struct Intersection tmp_j ccl_optional_struct_init;
-        struct Intersection tmp_j_1 ccl_optional_struct_init;
-        integrator_state_read_shadow_isect(state, &tmp_j, j);
-        integrator_state_read_shadow_isect(state, &tmp_j_1, j + 1);
-        integrator_state_write_shadow_isect(state, &tmp_j_1, j);
-        integrator_state_write_shadow_isect(state, &tmp_j, j + 1);
-        swapped = true;
-      }
-    }
-    --num_hits;
-  } while (swapped);
-#  else
-  Intersection *isect_array = (Intersection *)state->shadow_isect;
-  qsort(isect_array, num_hits, sizeof(Intersection), shadow_intersections_compare);
-#  endif
-}
-
-ccl_device bool integrate_intersect_shadow_transparent(KernelGlobals kg,
-                                                       IntegratorShadowState state,
-                                                       const ccl_private Ray *ray,
-                                                       const uint visibility)
-{
-  /* Limit the number hits to the max transparent bounces allowed and the size that we
-   * have available in the integrator state. */
-  const uint max_transparent_hits = integrate_shadow_max_transparent_hits(kg, state);
-  uint num_hits = 0;
-  float throughput = 1.0f;
-  bool opaque_hit = scene_intersect_shadow_all(
-      kg, state, ray, visibility, max_transparent_hits, &num_hits, &throughput);
-
-  /* Computed throughput from baked shadow transparency, where we can bypass recording
-   * intersections and shader evaluation. */
-  if (throughput != 1.0f) {
-    INTEGRATOR_STATE_WRITE(state, shadow_path, throughput) *= throughput;
-  }
-
-  if (!opaque_hit) {
-    const uint num_recorded_hits = min(num_hits, (uint)INTEGRATOR_SHADOW_ISECT_SIZE);
-
-    if (num_recorded_hits > 0) {
-      sort_shadow_intersections(state, num_recorded_hits);
-    }
-
-    INTEGRATOR_STATE_WRITE(state, shadow_path, num_hits) = num_hits;
-  }
-  else {
-    INTEGRATOR_STATE_WRITE(state, shadow_path, num_hits) = 0;
-  }
-
-  return opaque_hit;
-}
-#endif
-
-ccl_device void integrator_intersect_shadow(KernelGlobals kg, IntegratorShadowState state)
-{
-  PROFILING_INIT(kg, PROFILING_INTERSECT_SHADOW);
-
-  /* Read ray from integrator state into local memory. */
-  Ray ray ccl_optional_struct_init;
-  integrator_state_read_shadow_ray(state, &ray);
-  integrator_state_read_shadow_ray_self(state, &ray);
-  /* Compute visibility. */
-  const uint visibility = integrate_intersect_shadow_visibility(state);
-
-#ifdef __TRANSPARENT_SHADOWS__
-  /* TODO: compile different kernels depending on this? Especially for OptiX
-   * conditional trace calls are bad. */
-  const bool opaque_hit = (kernel_data.integrator.transparent_shadows) ?
-                              integrate_intersect_shadow_transparent(kg, state, &ray, visibility) :
-                              integrate_intersect_shadow_opaque(kg, state, &ray, visibility);
-#else
-  const bool opaque_hit = integrate_intersect_shadow_opaque(kg, state, &ray, visibility);
-#endif
-
-  if (opaque_hit) {
-    /* Hit an opaque surface, shadow path ends here. */
-    integrator_shadow_path_terminate(state, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW);
-    return;
-  }
-
-  /* Hit nothing or transparent surfaces, continue to shadow kernel
-   * for shading and render buffer output.
-   *
-   * TODO: could also write to render buffer directly if no transparent shadows?
-   * Could save a kernel execution for the common case. */
-  integrator_shadow_path_next(
-      state, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW, DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW);
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/integrator/intersect_subsurface.h

@@ -1,24 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/integrator/subsurface.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device void integrator_intersect_subsurface(KernelGlobals kg, IntegratorState state)
-{
-  PROFILING_INIT(kg, PROFILING_INTERSECT_SUBSURFACE);
-
-#ifdef __SUBSURFACE__
-  if (subsurface_scatter(kg, state)) {
-    return;
-  }
-#endif
-
-  integrator_path_terminate(kg, state, nullptr, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE);
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/integrator/intersect_volume_stack.h

@@ -1,250 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/bvh/bvh.h"
-
-#include "kernel/geom/shader_data.h"
-
-#include "kernel/integrator/intersect_closest.h"
-#include "kernel/integrator/volume_stack.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device void integrator_volume_stack_update_for_subsurface(KernelGlobals kg,
-                                                              IntegratorState state,
-                                                              const float3 from_P,
-                                                              const float3 to_P)
-{
-#ifdef __VOLUME__
-  PROFILING_INIT(kg, PROFILING_INTERSECT_VOLUME_STACK);
-
-  ShaderDataTinyStorage stack_sd_storage;
-  ccl_private ShaderData *stack_sd = AS_SHADER_DATA(&stack_sd_storage);
-
-  kernel_assert(kernel_data.integrator.use_volumes);
-
-  Ray volume_ray ccl_optional_struct_init;
-  volume_ray.P = from_P;
-  volume_ray.D = safe_normalize_len(to_P - from_P, &volume_ray.tmax);
-  volume_ray.tmin = 0.0f;
-  volume_ray.self.object = INTEGRATOR_STATE(state, isect, object);
-  volume_ray.self.prim = INTEGRATOR_STATE(state, isect, prim);
-  volume_ray.self.light_object = OBJECT_NONE;
-  volume_ray.self.light_prim = PRIM_NONE;
-  /* Store to avoid global fetches on every intersection step. */
-  const uint volume_stack_size = kernel_data.volume_stack_size;
-
-  const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-  const uint32_t visibility = SHADOW_CATCHER_PATH_VISIBILITY(path_flag, PATH_RAY_ALL_VISIBILITY);
-
-#  ifdef __VOLUME_RECORD_ALL__
-  Intersection hits[2 * MAX_VOLUME_STACK_SIZE + 1];
-  const uint num_hits = scene_intersect_volume(
-      kg, &volume_ray, hits, 2 * volume_stack_size, visibility);
-  if (num_hits > 0) {
-    Intersection *isect = hits;
-
-    qsort(hits, num_hits, sizeof(Intersection), intersections_compare);
-
-    for (uint hit = 0; hit < num_hits; ++hit, ++isect) {
-      /* Ignore self, SSS itself already enters and exits the object. */
-      if (isect->object == volume_ray.self.object) {
-        continue;
-      }
-      shader_setup_from_ray(kg, stack_sd, &volume_ray, isect);
-      volume_stack_enter_exit<false>(kg, state, stack_sd);
-    }
-  }
-#  else
-  Intersection isect;
-  int step = 0;
-  while (step < 2 * volume_stack_size &&
-         scene_intersect_volume(kg, &volume_ray, &isect, visibility))
-  {
-    /* Ignore self, SSS itself already enters and exits the object. */
-    if (isect.object != volume_ray.self.object) {
-      shader_setup_from_ray(kg, stack_sd, &volume_ray, &isect);
-      volume_stack_enter_exit<false>(kg, state, stack_sd);
-    }
-    /* Move ray forward. */
-    volume_ray.tmin = intersection_t_offset(isect.t);
-    volume_ray.self.object = isect.object;
-    volume_ray.self.prim = isect.prim;
-    ++step;
-  }
-#  endif
-}
-
-ccl_device void integrator_volume_stack_init(KernelGlobals kg, IntegratorState state)
-{
-  PROFILING_INIT(kg, PROFILING_INTERSECT_VOLUME_STACK);
-
-  ShaderDataTinyStorage stack_sd_storage;
-  ccl_private ShaderData *stack_sd = AS_SHADER_DATA(&stack_sd_storage);
-
-  Ray volume_ray ccl_optional_struct_init;
-  integrator_state_read_ray(state, &volume_ray);
-
-  /* Trace ray in random direction. Any direction works, Z up is a guess to get the
-   * fewest hits. */
-  volume_ray.D = make_float3(0.0f, 0.0f, 1.0f);
-  volume_ray.tmin = 0.0f;
-  volume_ray.tmax = FLT_MAX;
-  volume_ray.self.object = OBJECT_NONE;
-  volume_ray.self.prim = PRIM_NONE;
-  volume_ray.self.light_object = OBJECT_NONE;
-  volume_ray.self.light_prim = PRIM_NONE;
-
-  int stack_index = 0;
-  int enclosed_index = 0;
-
-  const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-  const uint32_t visibility = SHADOW_CATCHER_PATH_VISIBILITY(path_flag, PATH_RAY_CAMERA);
-
-  /* Initialize volume stack with background volume For shadow catcher the
-   * background volume is always assumed to be CG. */
-  if (kernel_data.background.volume_shader != SHADER_NONE) {
-    if (!(path_flag & PATH_RAY_SHADOW_CATCHER_PASS)) {
-      INTEGRATOR_STATE_ARRAY_WRITE(
-          state, volume_stack, stack_index, object) = kernel_data.background.object_index;
-      INTEGRATOR_STATE_ARRAY_WRITE(
-          state, volume_stack, stack_index, shader) = kernel_data.background.volume_shader;
-      stack_index++;
-    }
-  }
-
-  /* Store to avoid global fetches on every intersection step. */
-  const uint volume_stack_size = kernel_data.volume_stack_size;
-
-#  ifdef __VOLUME_RECORD_ALL__
-  Intersection hits[2 * MAX_VOLUME_STACK_SIZE + 1];
-  const uint num_hits = scene_intersect_volume(
-      kg, &volume_ray, hits, 2 * volume_stack_size, visibility);
-  if (num_hits > 0) {
-    int enclosed_volumes[MAX_VOLUME_STACK_SIZE];
-    Intersection *isect = hits;
-
-    qsort(hits, num_hits, sizeof(Intersection), intersections_compare);
-
-    for (uint hit = 0; hit < num_hits; ++hit, ++isect) {
-      shader_setup_from_ray(kg, stack_sd, &volume_ray, isect);
-      if (stack_sd->flag & SD_BACKFACING) {
-        bool need_add = true;
-        for (int i = 0; i < enclosed_index && need_add; ++i) {
-          /* If ray exited the volume and never entered to that volume
-           * it means that camera is inside such a volume.
-           */
-          if (enclosed_volumes[i] == stack_sd->object) {
-            need_add = false;
-          }
-        }
-        for (int i = 0; i < stack_index && need_add; ++i) {
-          /* Don't add intersections twice. */
-          const VolumeStack entry = integrator_state_read_volume_stack(state, i);
-          if (entry.object == stack_sd->object) {
-            need_add = false;
-            break;
-          }
-        }
-        if (need_add && stack_index < volume_stack_size - 1) {
-          const VolumeStack new_entry = {stack_sd->object, stack_sd->shader};
-          integrator_state_write_volume_stack(state, stack_index, new_entry);
-          ++stack_index;
-        }
-      }
-      else {
-        /* If ray from camera enters the volume, this volume shouldn't
-         * be added to the stack on exit.
-         */
-        enclosed_volumes[enclosed_index++] = stack_sd->object;
-      }
-    }
-  }
-#  else
-  /* CUDA does not support definition of a variable size arrays, so use the maximum possible. */
-  int enclosed_volumes[MAX_VOLUME_STACK_SIZE];
-  int step = 0;
-
-  while (stack_index < volume_stack_size - 1 && enclosed_index < MAX_VOLUME_STACK_SIZE - 1 &&
-         step < 2 * volume_stack_size)
-  {
-    Intersection isect;
-    if (!scene_intersect_volume(kg, &volume_ray, &isect, visibility)) {
-      break;
-    }
-
-    shader_setup_from_ray(kg, stack_sd, &volume_ray, &isect);
-    if (stack_sd->flag & SD_BACKFACING) {
-      /* If ray exited the volume and never entered to that volume
-       * it means that camera is inside such a volume.
-       */
-      bool need_add = true;
-      for (int i = 0; i < enclosed_index && need_add; ++i) {
-        /* If ray exited the volume and never entered to that volume
-         * it means that camera is inside such a volume.
-         */
-        if (enclosed_volumes[i] == stack_sd->object) {
-          need_add = false;
-        }
-      }
-      for (int i = 0; i < stack_index && need_add; ++i) {
-        /* Don't add intersections twice. */
-        VolumeStack entry = integrator_state_read_volume_stack(state, i);
-        if (entry.object == stack_sd->object) {
-          need_add = false;
-          break;
-        }
-      }
-      if (need_add) {
-        const VolumeStack new_entry = {stack_sd->object, stack_sd->shader};
-        integrator_state_write_volume_stack(state, stack_index, new_entry);
-        ++stack_index;
-      }
-    }
-    else {
-      /* If ray from camera enters the volume, this volume shouldn't
-       * be added to the stack on exit.
-       */
-      enclosed_volumes[enclosed_index++] = stack_sd->object;
-    }
-
-    /* Move ray forward. */
-    volume_ray.tmin = intersection_t_offset(isect.t);
-    volume_ray.self.object = isect.object;
-    volume_ray.self.prim = isect.prim;
-    ++step;
-  }
-#  endif
-
-  /* Write terminator. */
-  const VolumeStack new_entry = {OBJECT_NONE, SHADER_NONE};
-  integrator_state_write_volume_stack(state, stack_index, new_entry);
-#endif
-}
-
-ccl_device void integrator_intersect_volume_stack(KernelGlobals kg, IntegratorState state)
-{
-#ifdef __VOLUME__
-  integrator_volume_stack_init(kg, state);
-
-#  ifdef __SHADOW_CATCHER__
-  if (INTEGRATOR_STATE(state, path, flag) & PATH_RAY_SHADOW_CATCHER_PASS) {
-    /* Volume stack re-init for shadow catcher, continue with shading of hit. */
-    integrator_intersect_next_kernel_after_shadow_catcher_volume<
-        DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK>(kg, state);
-  }
-  else
-#  endif
-  {
-    /* Volume stack init for camera rays, continue with intersection of camera ray. */
-    integrator_path_next(state,
-                         DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK,
-                         DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST);
-  }
-#endif
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/integrator/megakernel.h

@@ -1,114 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/integrator/intersect_closest.h"
-#include "kernel/integrator/intersect_dedicated_light.h"
-#include "kernel/integrator/intersect_shadow.h"
-#include "kernel/integrator/intersect_subsurface.h"
-#include "kernel/integrator/intersect_volume_stack.h"
-#include "kernel/integrator/shade_background.h"
-#include "kernel/integrator/shade_dedicated_light.h"
-#include "kernel/integrator/shade_light.h"
-#include "kernel/integrator/shade_shadow.h"
-#include "kernel/integrator/shade_surface.h"
-#include "kernel/integrator/shade_volume.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device void integrator_megakernel(KernelGlobals kg,
-                                      IntegratorState state,
-                                      ccl_global float *ccl_restrict render_buffer)
-{
-  /* Each kernel indicates the next kernel to execute, so here we simply
-   * have to check what that kernel is and execute it. */
-  while (true) {
-    /* Handle any shadow paths before we potentially create more shadow paths. */
-    const uint32_t shadow_queued_kernel = INTEGRATOR_STATE(
-        &state->shadow, shadow_path, queued_kernel);
-    if (shadow_queued_kernel) {
-      switch (shadow_queued_kernel) {
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW:
-          integrator_intersect_shadow(kg, &state->shadow);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW:
-          integrator_shade_shadow(kg, &state->shadow, render_buffer);
-          break;
-        default:
-          kernel_assert(0);
-          break;
-      }
-      continue;
-    }
-
-    /* Handle any AO paths before we potentially create more AO paths. */
-    const uint32_t ao_queued_kernel = INTEGRATOR_STATE(&state->ao, shadow_path, queued_kernel);
-    if (ao_queued_kernel) {
-      switch (ao_queued_kernel) {
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW:
-          integrator_intersect_shadow(kg, &state->ao);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW:
-          integrator_shade_shadow(kg, &state->ao, render_buffer);
-          break;
-        default:
-          kernel_assert(0);
-          break;
-      }
-      continue;
-    }
-
-    /* Then handle regular path kernels. */
-    const uint32_t queued_kernel = INTEGRATOR_STATE(state, path, queued_kernel);
-    if (queued_kernel) {
-      switch (queued_kernel) {
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST:
-          integrator_intersect_closest(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND:
-          integrator_shade_background(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE:
-          integrator_shade_surface(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME:
-          integrator_shade_volume(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME_RAY_MARCHING:
-          integrator_shade_volume_ray_marching(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE:
-          integrator_shade_surface_raytrace(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_MNEE:
-          integrator_shade_surface_mnee(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT:
-          integrator_shade_light(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_SHADE_DEDICATED_LIGHT:
-          integrator_shade_dedicated_light(kg, state, render_buffer);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE:
-          integrator_intersect_subsurface(kg, state);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK:
-          integrator_intersect_volume_stack(kg, state);
-          break;
-        case DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT:
-          integrator_intersect_dedicated_light(kg, state);
-          break;
-        default:
-          kernel_assert(0);
-          break;
-      }
-      continue;
-    }
-
-    break;
-  }
-}
-
-CCL_NAMESPACE_END