@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,79 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/integrator/state_flow.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Check whether current surface bounce is where path is to be split for the shadow catcher. */
-ccl_device_inline bool kernel_shadow_catcher_is_path_split_bounce(KernelGlobals kg,
-                                                                  IntegratorState state,
-                                                                  const int object_flag)
-{
-#ifdef __SHADOW_CATCHER__
-  if (!kernel_data.integrator.has_shadow_catcher) {
-    return false;
-  }
-
-  /* Check the flag first, avoiding fetches form global memory. */
-  if ((object_flag & SD_OBJECT_SHADOW_CATCHER) == 0) {
-    return false;
-  }
-  if (object_flag & SD_OBJECT_HOLDOUT_MASK) {
-    return false;
-  }
-
-  const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-
-  if ((path_flag & PATH_RAY_TRANSPARENT_BACKGROUND) == 0) {
-    /* Split only on primary rays, secondary bounces are to treat shadow catcher as a regular
-     * object. */
-    return false;
-  }
-
-  if (path_flag & PATH_RAY_SHADOW_CATCHER_HIT) {
-    return false;
-  }
-
-  return true;
-#else
-  (void)object_flag;
-  return false;
-#endif
-}
-
-/* Check whether the current path can still split. */
-ccl_device_inline bool kernel_shadow_catcher_path_can_split(ConstIntegratorState state)
-{
-  if (integrator_path_is_terminated(state)) {
-    return false;
-  }
-
-  const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
-
-  if (path_flag & PATH_RAY_SHADOW_CATCHER_HIT) {
-    /* Shadow catcher was already hit and the state was split. No further split is allowed. */
-    return false;
-  }
-
-  return (path_flag & PATH_RAY_TRANSPARENT_BACKGROUND) != 0;
-}
-
-#ifdef __SHADOW_CATCHER__
-
-ccl_device_forceinline bool kernel_shadow_catcher_is_matte_path(const uint32_t path_flag)
-{
-  return (path_flag & PATH_RAY_SHADOW_CATCHER_HIT) == 0;
-}
-
-ccl_device_forceinline bool kernel_shadow_catcher_is_object_pass(const uint32_t path_flag)
-{
-  return path_flag & PATH_RAY_SHADOW_CATCHER_PASS;
-}
-
-#endif /* __SHADOW_CATCHER__ */
-
-CCL_NAMESPACE_END

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

@@ -1,69 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2023 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/integrator/state_flow.h"
-
-CCL_NAMESPACE_BEGIN
-
-#ifdef __SHADOW_LINKING__
-
-/* Check whether special shadow rays for shadow linking are needed in the current scene
- * configuration. */
-ccl_device_forceinline bool shadow_linking_scene_need_shadow_ray(KernelGlobals kg)
-{
-  if (!(kernel_data.kernel_features & KERNEL_FEATURE_SHADOW_LINKING)) {
-    /* No shadow linking in the scene, so no need to trace any extra rays. */
-    return false;
-  }
-
-  /* The distant lights might be using shadow linking, and they are not counted as
-   * kernel_data.integrator.use_light_mis.
-   * So there is a potential to avoid extra rays from being traced, but it requires more granular
-   * flags set in the integrator. */
-
-  return true;
-}
-
-/* Shadow linking re-used the main path intersection to store information about the light to which
- * the extra ray is to be traced (this intersection communicates light between the shadow blocker
- * intersection and shading kernels).
- * These utilities makes a copy of the fields from the main intersection which are needed by the
- * intersect_closest kernel after the surface bounce. */
-
-ccl_device_forceinline void shadow_linking_store_last_primitives(IntegratorState state)
-{
-  INTEGRATOR_STATE_WRITE(state, shadow_link, last_isect_prim) = INTEGRATOR_STATE(
-      state, isect, prim);
-  INTEGRATOR_STATE_WRITE(state, shadow_link, last_isect_object) = INTEGRATOR_STATE(
-      state, isect, object);
-}
-
-ccl_device_forceinline void shadow_linking_restore_last_primitives(IntegratorState state)
-{
-  INTEGRATOR_STATE_WRITE(state, isect, prim) = INTEGRATOR_STATE(
-      state, shadow_link, last_isect_prim);
-  INTEGRATOR_STATE_WRITE(state, isect, object) = INTEGRATOR_STATE(
-      state, shadow_link, last_isect_object);
-}
-
-/* Schedule shadow linking intersection kernel if it is needed.
- * Returns true if the shadow linking specific kernel has been scheduled, false otherwise. */
-template<DeviceKernel current_kernel>
-ccl_device_inline bool shadow_linking_schedule_intersection_kernel(KernelGlobals kg,
-                                                                   IntegratorState state)
-{
-  if (!shadow_linking_scene_need_shadow_ray(kg)) {
-    return false;
-  }
-
-  integrator_path_next(state, current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT);
-
-  return true;
-}
-
-#endif /* __SHADOW_LINKING__ */
-
-CCL_NAMESPACE_END

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

@@ -1,99 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-/********************************* Shadow Path State **************************/
-
-KERNEL_STRUCT_BEGIN(shadow_path)
-/* Index of a pixel within the device render buffer. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint32_t, render_pixel_index, KERNEL_FEATURE_PATH_TRACING)
-/* Current sample number. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint32_t, sample, KERNEL_FEATURE_PATH_TRACING)
-/* Random number generator per-pixel info. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint32_t, rng_pixel, KERNEL_FEATURE_PATH_TRACING)
-/* Random number dimension offset. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, rng_offset, KERNEL_FEATURE_PATH_TRACING)
-/* Current ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current transparent ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, transparent_bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current diffuse ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, diffuse_bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current glossy ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, glossy_bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current transmission ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, transmission_bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current volume bounds ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, volume_bounds_bounce, KERNEL_FEATURE_PATH_TRACING)
-/* Current portal ray bounce depth. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, portal_bounce, KERNEL_FEATURE_NODE_PORTAL)
-/* DeviceKernel bit indicating queued kernels. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, queued_kernel, KERNEL_FEATURE_PATH_TRACING)
-/* enum PathRayFlag */
-KERNEL_STRUCT_MEMBER(shadow_path, uint32_t, flag, KERNEL_FEATURE_PATH_TRACING)
-/* Throughput. */
-KERNEL_STRUCT_MEMBER(shadow_path, PackedSpectrum, throughput, KERNEL_FEATURE_PATH_TRACING)
-/* Throughput for shadow pass. */
-KERNEL_STRUCT_MEMBER(shadow_path,
-                     PackedSpectrum,
-                     unshadowed_throughput,
-                     KERNEL_FEATURE_AO_ADDITIVE)
-/* Ratio of throughput to distinguish diffuse / glossy / transmission render passes. */
-KERNEL_STRUCT_MEMBER(shadow_path, PackedSpectrum, pass_diffuse_weight, KERNEL_FEATURE_LIGHT_PASSES)
-KERNEL_STRUCT_MEMBER(shadow_path, PackedSpectrum, pass_glossy_weight, KERNEL_FEATURE_LIGHT_PASSES)
-/* Number of intersections found by ray-tracing.
- * Note that this is the total number of intersections for the shadow ray.
- * The number of recorded intersections in the shadow_isect array might be different as it contains
- * up INTEGRATOR_SHADOW_ISECT_SIZE closest intersections. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint16_t, num_hits, KERNEL_FEATURE_PATH_TRACING)
-/* Light group. */
-KERNEL_STRUCT_MEMBER(shadow_path, uint8_t, lightgroup, KERNEL_FEATURE_PATH_TRACING)
-/* Path guiding. */
-KERNEL_STRUCT_MEMBER(shadow_path, PackedSpectrum, unlit_throughput, KERNEL_FEATURE_PATH_GUIDING)
-#if defined(__PATH_GUIDING__)
-KERNEL_STRUCT_MEMBER(shadow_path,
-                     openpgl::cpp::PathSegment *,
-                     path_segment,
-                     KERNEL_FEATURE_PATH_GUIDING)
-#else
-KERNEL_STRUCT_MEMBER(shadow_path, uint64_t, path_segment, KERNEL_FEATURE_PATH_GUIDING)
-#endif
-KERNEL_STRUCT_MEMBER(shadow_path, float, guiding_mis_weight, KERNEL_FEATURE_PATH_GUIDING)
-KERNEL_STRUCT_END(shadow_path)
-
-/********************************** Shadow Ray *******************************/
-
-KERNEL_STRUCT_BEGIN_PACKED(shadow_ray, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, packed_float3, P, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, packed_float3, D, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, float, tmin, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, float, tmax, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, float, time, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, float, dP, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, int, self_light_object, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_MEMBER_PACKED(shadow_ray, int, self_light_prim, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_END(shadow_ray)
-
-/*********************** Shadow Intersection result **************************/
-
-/* Result from scene intersection.
- * It contains INTEGRATOR_SHADOW_ISECT_SIZE closest intersections of the shadow ray. */
-KERNEL_STRUCT_BEGIN(shadow_isect)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, float, t, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, float, u, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, float, v, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, int, prim, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, int, object, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_isect, int, type, KERNEL_FEATURE_PATH_TRACING)
-KERNEL_STRUCT_END_ARRAY(shadow_isect,
-                        INTEGRATOR_SHADOW_ISECT_SIZE_CPU,
-                        INTEGRATOR_SHADOW_ISECT_SIZE_GPU)
-
-/**************************** Shadow Volume Stack *****************************/
-
-KERNEL_STRUCT_BEGIN(shadow_volume_stack)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_volume_stack, int, object, KERNEL_FEATURE_VOLUME)
-KERNEL_STRUCT_ARRAY_MEMBER(shadow_volume_stack, int, shader, KERNEL_FEATURE_VOLUME)
-KERNEL_STRUCT_END_ARRAY(shadow_volume_stack,
-                        KERNEL_STRUCT_VOLUME_STACK_SIZE,
-                        KERNEL_STRUCT_VOLUME_STACK_SIZE)

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

@@ -1,276 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-/* Integrator State
- *
- * This file defines the data structures that define the state of a path. Any state that is
- * preserved and passed between kernel executions is part of this.
- *
- * The size of this state must be kept as small as possible, to reduce cache misses and keep memory
- * usage under control on GPUs that may execute millions of kernels.
- *
- * Memory may be allocated and passed along in different ways depending on the device. There may
- * be a scalar layout, or AoS or SoA layout for batches. The state may be passed along as a pointer
- * to every kernel, or the pointer may exist at program scope or in constant memory. To abstract
- * these differences between devices and experiment with different layouts, macros are used.
- *
- * Use IntegratorState to pass a reference to the integrator state for the current path. These are
- * defined differently on the CPU and GPU. Use ConstIntegratorState instead of const
- * IntegratorState for passing state as read-only, to avoid oddities in typedef behavior.
- *
- * INTEGRATOR_STATE(state, x, y): read nested struct member x.y of IntegratorState
- * INTEGRATOR_STATE_WRITE(state, x, y): write to nested struct member x.y of IntegratorState
- *
- * INTEGRATOR_STATE_ARRAY(state, x, index, y): read x[index].y
- * INTEGRATOR_STATE_ARRAY_WRITE(state, x, index, y): write x[index].y
- *
- * INTEGRATOR_STATE_NULL: use to pass empty state to other functions.
- */
-
-#include "kernel/types.h"
-
-#include "util/types.h"
-
-#if defined(__PATH_GUIDING__)
-#  include "util/guiding.h"  // IWYU pragma: keep
-#endif
-
-#pragma once
-
-CCL_NAMESPACE_BEGIN
-
-/* Data structures */
-
-/* Integrator State
- *
- * CPU rendering path state with AoS layout. */
-struct IntegratorShadowStateCPU {
-#define KERNEL_STRUCT_BEGIN(name) struct {
-#define KERNEL_STRUCT_BEGIN_PACKED(parent_struct, feature) struct {
-#define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) type name;
-#define KERNEL_STRUCT_MEMBER_PACKED KERNEL_STRUCT_MEMBER
-#define KERNEL_STRUCT_ARRAY_MEMBER KERNEL_STRUCT_MEMBER
-#define KERNEL_STRUCT_END(name) \
-  } \
-  name;
-#define KERNEL_STRUCT_END_ARRAY(name, cpu_size, gpu_size) \
-  } \
-  name[cpu_size];
-#define KERNEL_STRUCT_VOLUME_STACK_SIZE MAX_VOLUME_STACK_SIZE
-#include "kernel/integrator/shadow_state_template.h"
-#undef KERNEL_STRUCT_BEGIN
-#undef KERNEL_STRUCT_BEGIN_PACKED
-#undef KERNEL_STRUCT_MEMBER
-#undef KERNEL_STRUCT_MEMBER_PACKED
-#undef KERNEL_STRUCT_ARRAY_MEMBER
-#undef KERNEL_STRUCT_END
-#undef KERNEL_STRUCT_END_ARRAY
-};
-
-struct IntegratorStateCPU {
-#define KERNEL_STRUCT_BEGIN(name) struct {
-#define KERNEL_STRUCT_BEGIN_PACKED(parent_struct, feature) struct {
-#define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) type name;
-#define KERNEL_STRUCT_MEMBER_PACKED KERNEL_STRUCT_MEMBER
-#define KERNEL_STRUCT_ARRAY_MEMBER KERNEL_STRUCT_MEMBER
-#define KERNEL_STRUCT_END(name) \
-  } \
-  name;
-#define KERNEL_STRUCT_END_ARRAY(name, cpu_size, gpu_size) \
-  } \
-  name[cpu_size];
-#define KERNEL_STRUCT_VOLUME_STACK_SIZE MAX_VOLUME_STACK_SIZE
-#include "kernel/integrator/state_template.h"
-#undef KERNEL_STRUCT_BEGIN
-#undef KERNEL_STRUCT_BEGIN_PACKED
-#undef KERNEL_STRUCT_MEMBER
-#undef KERNEL_STRUCT_MEMBER_PACKED
-#undef KERNEL_STRUCT_ARRAY_MEMBER
-#undef KERNEL_STRUCT_END
-#undef KERNEL_STRUCT_END_ARRAY
-#undef KERNEL_STRUCT_VOLUME_STACK_SIZE
-
-  IntegratorShadowStateCPU shadow;
-  IntegratorShadowStateCPU ao;
-};
-
-/* Path Queue
- *
- * Keep track of which kernels are queued to be executed next in the path
- * for GPU rendering. */
-struct IntegratorQueueCounter {
-  int num_queued[DEVICE_KERNEL_INTEGRATOR_NUM];
-};
-
-#if defined(__INTEGRATOR_GPU_PACKED_STATE__) && defined(__KERNEL_GPU__)
-
-/* Generate wrapper structs for all integrator state fields. This allows us to access state
- * uniformly, regardless of whether it stored in a packed struct or separate arrays. */
-#  define KERNEL_STRUCT_BEGIN(name)
-#  define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) \
-    struct Wrapped_##parent_struct##_##name { \
-      type name; \
-    };
-#  define KERNEL_STRUCT_MEMBER_PACKED KERNEL_STRUCT_MEMBER
-#  define KERNEL_STRUCT_BEGIN_PACKED(parent_struct, feature) \
-    KERNEL_STRUCT_BEGIN(parent_struct) \
-    KERNEL_STRUCT_MEMBER(parent_struct, packed_##parent_struct, packed, feature)
-#  define KERNEL_STRUCT_ARRAY_MEMBER KERNEL_STRUCT_MEMBER
-#  define KERNEL_STRUCT_END(name)
-#  define KERNEL_STRUCT_END_ARRAY(name, cpu_size, gpu_size)
-#  define KERNEL_STRUCT_VOLUME_STACK_SIZE MAX_VOLUME_STACK_SIZE
-
-#  include "kernel/integrator/shadow_state_template.h"
-#  include "kernel/integrator/state_template.h"
-
-#  undef KERNEL_STRUCT_BEGIN
-#  undef KERNEL_STRUCT_BEGIN_PACKED
-#  undef KERNEL_STRUCT_MEMBER
-#  undef KERNEL_STRUCT_MEMBER_PACKED
-#  undef KERNEL_STRUCT_ARRAY_MEMBER
-#  undef KERNEL_STRUCT_END
-#  undef KERNEL_STRUCT_END_ARRAY
-#  undef KERNEL_STRUCT_VOLUME_STACK_SIZE
-
-#endif
-
-/* Integrator State GPU
- *
- * GPU rendering path state with SoA layout. */
-struct IntegratorStateGPU {
-#define KERNEL_STRUCT_BEGIN(name) struct {
-
-#ifdef __INTEGRATOR_GPU_PACKED_STATE__
-
-#  ifdef __KERNEL_GPU__
-
-/* If we've opted in to packed layouts, generate member functions that return a pointer to a
- * wrapper type so we can access state using uniform syntax. */
-#    define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) \
-      ccl_global Wrapped_##parent_struct##_##name *name; \
-      ccl_device_inline ccl_global Wrapped_##parent_struct##_##name *name##_fn() ccl_constant \
-      { \
-        return (ccl_global Wrapped_##parent_struct##_##name *)name; \
-      }
-#    define KERNEL_STRUCT_MEMBER_PACKED(parent_struct, type, name, feature) \
-      ccl_device_inline ccl_global packed_##parent_struct *name##_fn() ccl_constant \
-      { \
-        return (ccl_global packed_##parent_struct *)packed; \
-      }
-#  else
-#    define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) ccl_global type *name;
-#    define KERNEL_STRUCT_MEMBER_PACKED(parent_struct, type, name, feature)
-#  endif
-
-#  define KERNEL_STRUCT_BEGIN_PACKED(parent_struct, feature) \
-    KERNEL_STRUCT_BEGIN(parent_struct) \
-    KERNEL_STRUCT_MEMBER(parent_struct, packed_##parent_struct, packed, feature)
-
-#else
-#  define KERNEL_STRUCT_MEMBER(parent_struct, type, name, feature) ccl_global type *name;
-#  define KERNEL_STRUCT_MEMBER_PACKED KERNEL_STRUCT_MEMBER
-#  define KERNEL_STRUCT_BEGIN_PACKED(parent_struct, feature) KERNEL_STRUCT_BEGIN(parent_struct)
-#endif
-#define KERNEL_STRUCT_ARRAY_MEMBER KERNEL_STRUCT_MEMBER
-#define KERNEL_STRUCT_END(name) \
-  } \
-  name;
-#define KERNEL_STRUCT_END_ARRAY(name, cpu_size, gpu_size) \
-  } \
-  name[gpu_size];
-#define KERNEL_STRUCT_VOLUME_STACK_SIZE MAX_VOLUME_STACK_SIZE
-
-#include "kernel/integrator/state_template.h"
-
-#include "kernel/integrator/shadow_state_template.h"
-
-#undef KERNEL_STRUCT_BEGIN
-#undef KERNEL_STRUCT_BEGIN_PACKED
-#undef KERNEL_STRUCT_MEMBER
-#undef KERNEL_STRUCT_MEMBER_PACKED
-#undef KERNEL_STRUCT_ARRAY_MEMBER
-#undef KERNEL_STRUCT_END
-#undef KERNEL_STRUCT_END_ARRAY
-#undef KERNEL_STRUCT_VOLUME_STACK_SIZE
-
-  /* Count number of queued kernels. */
-  ccl_global IntegratorQueueCounter *queue_counter;
-
-  /* Count number of kernels queued for specific shaders. */
-  ccl_global int *sort_key_counter[DEVICE_KERNEL_INTEGRATOR_NUM];
-
-  /* Index of shadow path which will be used by a next shadow path. */
-  ccl_global int *next_shadow_path_index;
-
-  /* Index of main path which will be used by a next shadow catcher split. */
-  ccl_global int *next_main_path_index;
-
-  /* Partition/key offsets used when writing sorted active indices. */
-  ccl_global int *sort_partition_key_offsets;
-
-  /* Divisor used to partition active indices by locality when sorting by material. */
-  uint sort_partition_divisor;
-};
-
-/* Abstraction
- *
- * Macros to access data structures on different devices.
- *
- * Note that there is a special access function for the shadow catcher state. This access is to
- * happen from a kernel which operates on a "main" path. Attempt to use shadow catcher accessors
- * from a kernel which operates on a shadow catcher state will cause bad memory access. */
-
-#ifndef __KERNEL_GPU__
-
-/* Scalar access on CPU. */
-
-using IntegratorState = IntegratorStateCPU *;
-using ConstIntegratorState = const IntegratorStateCPU *;
-using IntegratorShadowState = IntegratorShadowStateCPU *;
-using ConstIntegratorShadowState = const IntegratorShadowStateCPU *;
-
-#  define INTEGRATOR_STATE_NULL nullptr
-
-#  define INTEGRATOR_STATE(state, nested_struct, member) ((state)->nested_struct.member)
-#  define INTEGRATOR_STATE_WRITE(state, nested_struct, member) ((state)->nested_struct.member)
-
-#  define INTEGRATOR_STATE_ARRAY(state, nested_struct, array_index, member) \
-    ((state)->nested_struct[array_index].member)
-#  define INTEGRATOR_STATE_ARRAY_WRITE(state, nested_struct, array_index, member) \
-    ((state)->nested_struct[array_index].member)
-
-#else /* !__KERNEL_GPU__ */
-
-/* Array access on GPU with Structure-of-Arrays. */
-
-using IntegratorState = int;
-using ConstIntegratorState = int;
-using IntegratorShadowState = int;
-using ConstIntegratorShadowState = int;
-
-#  define INTEGRATOR_STATE_NULL -1
-
-#  ifdef __INTEGRATOR_GPU_PACKED_STATE__
-
-/* If we've opted in to packed layouts, we use the generated accessor functions (member##_fn) to
- * resolve different layouts (packed vs separate). */
-#    define INTEGRATOR_STATE(state, nested_struct, member) \
-      kernel_integrator_state.nested_struct.member##_fn()[state].member
-#    define INTEGRATOR_STATE_ARRAY(state, nested_struct, array_index, member) \
-      kernel_integrator_state.nested_struct[array_index].member##_fn()[state].member
-#  else
-#    define INTEGRATOR_STATE(state, nested_struct, member) \
-      kernel_integrator_state.nested_struct.member[state]
-#    define INTEGRATOR_STATE_ARRAY(state, nested_struct, array_index, member) \
-      kernel_integrator_state.nested_struct[array_index].member[state]
-#  endif
-
-#  define INTEGRATOR_STATE_WRITE(state, nested_struct, member) \
-    INTEGRATOR_STATE(state, nested_struct, member)
-#  define INTEGRATOR_STATE_ARRAY_WRITE(state, nested_struct, array_index, member) \
-    INTEGRATOR_STATE_ARRAY(state, nested_struct, array_index, member)
-
-#endif /* !__KERNEL_GPU__ */
-
-CCL_NAMESPACE_END