@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/sample/sobol_burley.h

@@ -1,203 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-/*
- * A shuffled, Owen-scrambled Sobol sampler, implemented with the
- * techniques from the paper "Practical Hash-based Owen Scrambling"
- * by Brent Burley, 2020, Journal of Computer Graphics Techniques.
- *
- * Note that unlike a standard high-dimensional Sobol sequence, this
- * Sobol sampler uses padding to achieve higher dimensions, as described
- * in Burley's paper.
- */
-
-#pragma once
-
-#include "kernel/tables.h"
-
-#include "kernel/sample/util.h"
-
-#include "util/hash.h"
-
-CCL_NAMESPACE_BEGIN
-
-/*
- * Computes a single dimension of a sample from an Owen-scrambled
- * Sobol sequence.  This is used in the main sampling functions,
- * sobol_burley_sample_#D(), below.
- *
- * - rev_bit_index: the sample index, with reversed order bits.
- * - dimension:     the sample dimension.
- * - scramble_seed: the Owen scrambling seed.
- *
- * Note that the seed must be well randomized before being
- * passed to this function.
- */
-ccl_device_forceinline float sobol_burley(uint rev_bit_index,
-                                          const uint dimension,
-                                          const uint scramble_seed)
-{
-  uint result = 0;
-
-  if (dimension == 0) {
-    /* Fast-path for dimension 0, which is just Van der corput.
-     * This makes a notable difference in performance since we reuse
-     * dimensions for padding, and dimension 0 is reused the most. */
-    result = reverse_integer_bits(rev_bit_index);
-  }
-  else {
-    uint i = 0;
-    while (rev_bit_index != 0) {
-      const uint j = count_leading_zeros(rev_bit_index);
-      result ^= sobol_burley_table[dimension][i + j];
-      i += j + 1;
-
-      /* We can't do `<<= j + 1` because that can overflow the shift
-       * operator, which doesn't do what we need, at least on x86. */
-      rev_bit_index <<= j;
-      rev_bit_index <<= 1;
-    }
-  }
-
-  /* Apply Owen scrambling. */
-  result = reverse_integer_bits(reversed_bit_owen(result, scramble_seed));
-
-  return uint_to_float_excl(result);
-}
-
-/*
- * NOTE: the functions below intentionally produce samples that are
- * uncorrelated between functions.  For example, a 1D sample and 2D
- * sample produced with the same index, dimension, and seed are
- * uncorrelated with each other.  This allows more care-free usage
- * of the functions together, without having to worry about
- * e.g. 1D and 2D samples being accidentally correlated with each
- * other.
- */
-
-/*
- * Computes a 1D Owen-scrambled and shuffled Sobol sample.
- *
- * `index` is the index of the sample in the sequence.
- *
- * `dimension` is which dimensions of the sample you want to fetch.  Note
- * that different 1D dimensions are uncorrelated.  For samples with > 1D
- * stratification, use the multi-dimensional sampling methods below.
- *
- * `seed`: different seeds produce statistically independent,
- * uncorrelated sequences.
- *
- * `shuffled_index_mask` limits the sample sequence length, improving
- * performance. It must be a string of binary 1 bits followed by a
- * string of binary 0 bits (e.g. 0xffff0000) for the sampler to operate
- * correctly. In general, `reverse_integer_bits(shuffled_index_mask)`
- * should be >= the maximum number of samples expected to be taken. A safe
- * default (but least performant) is 0xffffffff, for maximum sequence
- * length.
- */
-ccl_device float sobol_burley_sample_1D(uint index,
-                                        const uint dimension,
-                                        uint seed,
-                                        const uint shuffled_index_mask)
-{
-  /* Include the dimension in the seed, so we get decorrelated
-   * sequences for different dimensions via shuffling. */
-  seed ^= hash_hp_uint(dimension);
-
-  /* Shuffle and mask.  The masking is just for better
-   * performance at low sample counts. */
-  index = reversed_bit_owen(reverse_integer_bits(index), seed ^ 0xbff95bfe);
-  index &= shuffled_index_mask;
-
-  return sobol_burley(index, 0, seed ^ 0x635c77bd);
-}
-
-/*
- * Computes a 2D Owen-scrambled and shuffled Sobol sample.
- *
- * `dimension_set` is which two dimensions of the sample you want to
- * fetch.  For example, 0 is the first two, 1 is the second two, etc.
- * The dimensions within a single set are stratified, but different sets
- * are uncorrelated.
- *
- * See sobol_burley_sample_1D for further usage details.
- */
-ccl_device float2 sobol_burley_sample_2D(uint index,
-                                         const uint dimension_set,
-                                         uint seed,
-                                         const uint shuffled_index_mask)
-{
-  /* Include the dimension set in the seed, so we get decorrelated
-   * sequences for different dimension sets via shuffling. */
-  seed ^= hash_hp_uint(dimension_set);
-
-  /* Shuffle and mask.  The masking is just for better
-   * performance at low sample counts. */
-  index = reversed_bit_owen(reverse_integer_bits(index), seed ^ 0xf8ade99a);
-  index &= shuffled_index_mask;
-
-  return make_float2(sobol_burley(index, 0, seed ^ 0xe0aaaf76),
-                     sobol_burley(index, 1, seed ^ 0x94964d4e));
-}
-
-/*
- * Computes a 3D Owen-scrambled and shuffled Sobol sample.
- *
- * `dimension_set` is which three dimensions of the sample you want to
- * fetch.  For example, 0 is the first three, 1 is the second three, etc.
- * The dimensions within a single set are stratified, but different sets
- * are uncorrelated.
- *
- * See sobol_burley_sample_1D for further usage details.
- */
-ccl_device float3 sobol_burley_sample_3D(uint index,
-                                         const uint dimension_set,
-                                         uint seed,
-                                         const uint shuffled_index_mask)
-{
-  /* Include the dimension set in the seed, so we get decorrelated
-   * sequences for different dimension sets via shuffling. */
-  seed ^= hash_hp_uint(dimension_set);
-
-  /* Shuffle and mask.  The masking is just for better
-   * performance at low sample counts. */
-  index = reversed_bit_owen(reverse_integer_bits(index), seed ^ 0xcaa726ac);
-  index &= shuffled_index_mask;
-
-  return make_float3(sobol_burley(index, 0, seed ^ 0x9e78e391),
-                     sobol_burley(index, 1, seed ^ 0x67c33241),
-                     sobol_burley(index, 2, seed ^ 0x78c395c5));
-}
-
-/*
- * Computes a 4D Owen-scrambled and shuffled Sobol sample.
- *
- * `dimension_set` is which four dimensions of the sample you want to
- * fetch.  For example, 0 is the first four, 1 is the second four, etc.
- * The dimensions within a single set are stratified, but different sets
- * are uncorrelated.
- *
- * See sobol_burley_sample_1D for further usage details.
- */
-ccl_device float4 sobol_burley_sample_4D(uint index,
-                                         const uint dimension_set,
-                                         uint seed,
-                                         const uint shuffled_index_mask)
-{
-  /* Include the dimension set in the seed, so we get decorrelated
-   * sequences for different dimension sets via shuffling. */
-  seed ^= hash_hp_uint(dimension_set);
-
-  /* Shuffle and mask.  The masking is just for better
-   * performance at low sample counts. */
-  index = reversed_bit_owen(reverse_integer_bits(index), seed ^ 0xc2c1a055);
-  index &= shuffled_index_mask;
-
-  return make_float4(sobol_burley(index, 0, seed ^ 0x39468210),
-                     sobol_burley(index, 1, seed ^ 0xe9d8a845),
-                     sobol_burley(index, 2, seed ^ 0x5f32b482),
-                     sobol_burley(index, 3, seed ^ 0x1524cc56));
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/sample/tabulated_sobol.h

@@ -1,178 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#include "kernel/globals.h"
-
-#include "kernel/sample/util.h"
-
-#include "util/hash.h"
-
-#pragma once
-CCL_NAMESPACE_BEGIN
-
-ccl_device uint tabulated_sobol_shuffled_sample_index(KernelGlobals kg,
-                                                      uint sample,
-                                                      const uint dimension,
-                                                      const uint seed)
-{
-  const uint sample_count = kernel_data.integrator.tabulated_sobol_sequence_size;
-
-  /* Shuffle the pattern order and sample index to decorrelate
-   * dimensions and make the most of the finite patterns we have.
-   * The funky sample mask stuff is to ensure that we only shuffle
-   * *within* the current sample pattern, which is necessary to avoid
-   * early repeat pattern use. */
-  const uint pattern_i = hash_shuffle_uint(dimension, NUM_TAB_SOBOL_PATTERNS, seed);
-  /* sample_count should always be a power of two, so this results in a mask. */
-  const uint sample_mask = sample_count - 1;
-  const uint sample_shuffled = nested_uniform_scramble(sample,
-                                                       hash_wang_seeded_uint(dimension, seed));
-  sample = (sample & ~sample_mask) | (sample_shuffled & sample_mask);
-
-  return ((pattern_i * sample_count) + sample) % (sample_count * NUM_TAB_SOBOL_PATTERNS);
-}
-
-ccl_device float tabulated_sobol_sample_1D(KernelGlobals kg,
-                                           const uint sample,
-                                           const uint rng_hash,
-                                           const uint dimension)
-{
-  uint seed = rng_hash;
-
-  /* Use the same sample sequence seed for all pixels when using
-   * scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    seed = kernel_data.integrator.seed;
-  }
-
-  /* Fetch the sample. */
-  const uint index = tabulated_sobol_shuffled_sample_index(kg, sample, dimension, seed);
-  float x = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS);
-
-  /* Do limited Cranley-Patterson rotation when using scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    const float jitter_x = hash_wang_seeded_float(dimension, rng_hash) *
-                           kernel_data.integrator.scrambling_distance;
-    x += jitter_x;
-    x -= floorf(x);
-  }
-
-  return x;
-}
-
-ccl_device float2 tabulated_sobol_sample_2D(KernelGlobals kg,
-                                            const uint sample,
-                                            const uint rng_hash,
-                                            const uint dimension)
-{
-  uint seed = rng_hash;
-
-  /* Use the same sample sequence seed for all pixels when using
-   * scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    seed = kernel_data.integrator.seed;
-  }
-
-  /* Fetch the sample. */
-  const uint index = tabulated_sobol_shuffled_sample_index(kg, sample, dimension, seed);
-  float x = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS);
-  float y = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 1);
-
-  /* Do limited Cranley-Patterson rotation when using scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    const float jitter_x = hash_wang_seeded_float(dimension, rng_hash) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_y = hash_wang_seeded_float(dimension, rng_hash ^ 0xca0e1151) *
-                           kernel_data.integrator.scrambling_distance;
-    x += jitter_x;
-    y += jitter_y;
-    x -= floorf(x);
-    y -= floorf(y);
-  }
-
-  return make_float2(x, y);
-}
-
-ccl_device float3 tabulated_sobol_sample_3D(KernelGlobals kg,
-                                            const uint sample,
-                                            const uint rng_hash,
-                                            const uint dimension)
-{
-  uint seed = rng_hash;
-
-  /* Use the same sample sequence seed for all pixels when using
-   * scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    seed = kernel_data.integrator.seed;
-  }
-
-  /* Fetch the sample. */
-  const uint index = tabulated_sobol_shuffled_sample_index(kg, sample, dimension, seed);
-  float x = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS);
-  float y = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 1);
-  float z = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 2);
-
-  /* Do limited Cranley-Patterson rotation when using scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    const float jitter_x = hash_wang_seeded_float(dimension, rng_hash) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_y = hash_wang_seeded_float(dimension, rng_hash ^ 0xca0e1151) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_z = hash_wang_seeded_float(dimension, rng_hash ^ 0xbf604c5a) *
-                           kernel_data.integrator.scrambling_distance;
-    x += jitter_x;
-    y += jitter_y;
-    z += jitter_z;
-    x -= floorf(x);
-    y -= floorf(y);
-    z -= floorf(z);
-  }
-
-  return make_float3(x, y, z);
-}
-
-ccl_device float4 tabulated_sobol_sample_4D(KernelGlobals kg,
-                                            const uint sample,
-                                            const uint rng_hash,
-                                            const uint dimension)
-{
-  uint seed = rng_hash;
-
-  /* Use the same sample sequence seed for all pixels when using
-   * scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    seed = kernel_data.integrator.seed;
-  }
-
-  /* Fetch the sample. */
-  const uint index = tabulated_sobol_shuffled_sample_index(kg, sample, dimension, seed);
-  float x = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS);
-  float y = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 1);
-  float z = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 2);
-  float w = kernel_data_fetch(sample_pattern_lut, index * NUM_TAB_SOBOL_DIMENSIONS + 3);
-
-  /* Do limited Cranley-Patterson rotation when using scrambling distance. */
-  if (kernel_data.integrator.scrambling_distance < 1.0f) {
-    const float jitter_x = hash_wang_seeded_float(dimension, rng_hash) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_y = hash_wang_seeded_float(dimension, rng_hash ^ 0xca0e1151) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_z = hash_wang_seeded_float(dimension, rng_hash ^ 0xbf604c5a) *
-                           kernel_data.integrator.scrambling_distance;
-    const float jitter_w = hash_wang_seeded_float(dimension, rng_hash ^ 0x99634d1d) *
-                           kernel_data.integrator.scrambling_distance;
-    x += jitter_x;
-    y += jitter_y;
-    z += jitter_z;
-    w += jitter_w;
-    x -= floorf(x);
-    y -= floorf(y);
-    z -= floorf(z);
-    w -= floorf(w);
-  }
-
-  return make_float4(x, y, z, w);
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/sample/util.h

@@ -1,79 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "util/math.h"
-#include "util/types.h"
-
-CCL_NAMESPACE_BEGIN
-
-/*
- * Performs base-2 Owen scrambling on a reversed-bit unsigned integer.
- *
- * This is equivalent to the Laine-Karras permutation, but much higher
- * quality.  See https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
- */
-ccl_device_inline uint reversed_bit_owen(uint n, const uint seed)
-{
-  n ^= n * 0x3d20adea;
-  n += seed;
-  n *= (seed >> 16) | 1;
-  n ^= n * 0x05526c56;
-  n ^= n * 0x53a22864;
-
-  return n;
-}
-
-/*
- * Performs base-4 Owen scrambling on a reversed-bit unsigned integer.
- *
- * See https://psychopath.io/post/2022_08_14_a_fast_hash_for_base_4_owen_scrambling
- */
-
-ccl_device_inline uint reversed_bit_owen_base4(uint n, const uint seed)
-{
-  n ^= n * 0x3d20adea;
-  n ^= (n >> 1) & (n << 1) & 0x55555555;
-  n += seed;
-  n *= (seed >> 16) | 1;
-  n ^= (n >> 1) & (n << 1) & 0x55555555;
-  n ^= n * 0x05526c56;
-  n ^= n * 0x53a22864;
-
-  return n;
-}
-
-/*
- * Performs base-2 Owen scrambling on an unsigned integer.
- */
-ccl_device_inline uint nested_uniform_scramble(const uint i, const uint seed)
-{
-  return reverse_integer_bits(reversed_bit_owen(reverse_integer_bits(i), seed));
-}
-
-/*
- * Performs base-4 Owen scrambling on an unsigned integer.
- */
-ccl_device_inline uint nested_uniform_scramble_base4(const uint i, const uint seed)
-{
-  return reverse_integer_bits(reversed_bit_owen_base4(reverse_integer_bits(i), seed));
-}
-
-ccl_device_inline uint expand_bits(uint x)
-{
-  x &= 0x0000ffff;
-  x = (x ^ (x << 8)) & 0x00ff00ff;
-  x = (x ^ (x << 4)) & 0x0f0f0f0f;
-  x = (x ^ (x << 2)) & 0x33333333;
-  x = (x ^ (x << 1)) & 0x55555555;
-  return x;
-}
-
-ccl_device_inline uint morton2d(const uint x, const uint y)
-{
-  return (expand_bits(x) << 1) | expand_bits(y);
-}
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/svm/ao.h

@@ -1,148 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/globals.h"
-
-#include "kernel/integrator/path_state.h"
-
-#include "kernel/bvh/bvh.h"
-
-#include "kernel/sample/mapping.h"
-
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-#ifdef __SHADER_RAYTRACE__
-
-#  ifdef __KERNEL_OPTIX__
-extern "C" __device__ float __direct_callable__svm_node_ao(
-#  else
-ccl_device float svm_ao(
-#  endif
-    KernelGlobals kg,
-    ConstIntegratorState state,
-    ccl_private ShaderData *sd,
-    float3 N,
-    float max_dist,
-    const int num_samples,
-    const int flags)
-{
-  if (flags & NODE_AO_GLOBAL_RADIUS) {
-    max_dist = kernel_data.integrator.ao_bounces_distance;
-  }
-
-  /* Early out if no sampling needed. */
-  if (max_dist <= 0.0f || num_samples < 1 || sd->object == OBJECT_NONE) {
-    return 1.0f;
-  }
-
-  /* Can't ray-trace from shaders like displacement, before BVH exists. */
-  if (kernel_data.bvh.bvh_layout == BVH_LAYOUT_NONE) {
-    return 1.0f;
-  }
-
-  if (flags & NODE_AO_INSIDE) {
-    N = -N;
-  }
-
-  float3 T;
-  float3 B;
-  make_orthonormals(N, &T, &B);
-
-  /* TODO: support ray-tracing in shadow shader evaluation? */
-  RNGState rng_state;
-  path_state_rng_load(state, &rng_state);
-
-  int unoccluded = 0;
-  for (int sample = 0; sample < num_samples; sample++) {
-    const float2 rand_disk = path_branched_rng_2D(
-        kg, &rng_state, sample, num_samples, PRNG_SURFACE_AO);
-
-    const float2 d = sample_uniform_disk(rand_disk);
-    const float3 D = make_float3(d.x, d.y, safe_sqrtf(1.0f - dot(d, d)));
-
-    /* Create ray. */
-    Ray ray;
-    ray.P = sd->P;
-    ray.D = to_global(D, T, B, N);
-    ray.tmin = 0.0f;
-    ray.tmax = max_dist;
-    ray.time = sd->time;
-    ray.self.object = sd->object;
-    ray.self.prim = sd->prim;
-    ray.self.light_object = OBJECT_NONE;
-    ray.self.light_prim = PRIM_NONE;
-    ray.dP = differential_zero_compact();
-    ray.dD = differential_zero_compact();
-
-    if (flags & NODE_AO_ONLY_LOCAL) {
-      if (!scene_intersect_local(kg, &ray, nullptr, sd->object, nullptr, 0)) {
-        unoccluded++;
-      }
-    }
-    else {
-      if (!scene_intersect_shadow(kg, &ray, PATH_RAY_SHADOW_OPAQUE)) {
-        unoccluded++;
-      }
-    }
-  }
-
-  return ((float)unoccluded) / num_samples;
-}
-
-template<uint node_feature_mask, typename ConstIntegratorGenericState>
-#  if defined(__KERNEL_OPTIX__)
-ccl_device_inline
-#  else
-ccl_device_noinline
-#  endif
-    void
-    svm_node_ao(KernelGlobals kg,
-                ConstIntegratorGenericState state,
-                ccl_private ShaderData *sd,
-                ccl_private float *stack,
-                const uint4 node)
-{
-  uint flags;
-  uint dist_offset;
-  uint normal_offset;
-  uint out_ao_offset;
-  svm_unpack_node_uchar4(node.y, &flags, &dist_offset, &normal_offset, &out_ao_offset);
-
-  uint color_offset;
-  uint out_color_offset;
-  uint samples;
-  svm_unpack_node_uchar3(node.z, &color_offset, &out_color_offset, &samples);
-
-  float ao = 1.0f;
-
-  IF_KERNEL_NODES_FEATURE(RAYTRACE)
-  {
-    float dist = stack_load_float_default(stack, dist_offset, node.w);
-    float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N;
-    normal = safe_normalize(normal);
-
-#  ifdef __KERNEL_OPTIX__
-    ao = optixDirectCall<float>(0, kg, state, sd, normal, dist, samples, flags);
-#  else
-    ao = svm_ao(kg, state, sd, normal, dist, samples, flags);
-#  endif
-  }
-
-  if (stack_valid(out_ao_offset)) {
-    stack_store_float(stack, out_ao_offset, ao);
-  }
-
-  if (stack_valid(out_color_offset)) {
-    const float3 color = stack_load_float3(stack, color_offset);
-    stack_store_float3(stack, out_color_offset, ao * color);
-  }
-}
-
-#endif /* __SHADER_RAYTRACE__ */
-
-CCL_NAMESPACE_END

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/svm/aov.h

@@ -1,49 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/film/aov_passes.h"
-
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device_inline bool svm_node_aov_check(const uint32_t path_flag,
-                                          const ccl_global float *render_buffer)
-{
-  const bool is_primary = (path_flag & PATH_RAY_TRANSPARENT_BACKGROUND) &&
-                          (!(path_flag & PATH_RAY_SINGLE_PASS_DONE));
-
-  return ((render_buffer != nullptr) && is_primary);
-}
-
-template<uint node_feature_mask, typename ConstIntegratorGenericState>
-ccl_device void svm_node_aov_color(KernelGlobals kg,
-                                   ConstIntegratorGenericState state,
-                                   ccl_private float *stack,
-                                   const uint4 node,
-                                   ccl_global float *render_buffer)
-{
-  IF_KERNEL_NODES_FEATURE(AOV)
-  {
-    const float3 val = stack_load_float3(stack, node.y);
-    film_write_aov_pass_color(kg, state, render_buffer, node.z, val);
-  }
-}
-
-template<uint node_feature_mask, typename ConstIntegratorGenericState>
-ccl_device void svm_node_aov_value(KernelGlobals kg,
-                                   ConstIntegratorGenericState state,
-                                   ccl_private float *stack,
-                                   const uint4 node,
-                                   ccl_global float *render_buffer)
-{
-  IF_KERNEL_NODES_FEATURE(AOV)
-  {
-    const float val = stack_load_float(stack, node.y);
-    film_write_aov_pass_value(kg, state, render_buffer, node.z, val);
-  }
-}
-CCL_NAMESPACE_END