@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/cycles/source/kernel/osl/types.h

@@ -1,157 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#if !defined(__KERNEL_GPU__)
-#  include <OSL/oslversion.h>
-#endif
-
-#include "kernel/types.h"
-
-#include "util/defines.h"
-#include "util/types_float3.h"
-
-CCL_NAMESPACE_BEGIN
-
-#if defined(__KERNEL_GPU__)
-/* Strings are represented by their hashes on the GPU. */
-using DeviceString = size_t;
-#elif defined(OPENIMAGEIO_USTRING_H)
-#  if OSL_LIBRARY_VERSION_CODE >= 11400
-using DeviceString = ustringhash;
-#  else
-using DeviceString = ustring;
-#  endif
-#else
-using DeviceString = const char *;
-#endif
-
-struct ThreadKernelGlobalsCPU;
-struct IntegratorStateCPU;
-struct IntegratorShadowStateCPU;
-struct OSLTraceData;
-
-ccl_device_inline DeviceString make_string(const char *str, const size_t hash)
-{
-#if defined(__KERNEL_GPU__)
-  (void)str;
-  return hash;
-#elif defined(OPENIMAGEIO_USTRING_H)
-  (void)hash; /* Ignored in release builds. */
-  const DeviceString result = ustring(str);
-  kernel_assert(result.hash() == hash);
-  return result;
-#else
-  (void)hash;
-  return str;
-#endif
-}
-
-/* Closure */
-
-enum OSLClosureType {
-  OSL_CLOSURE_MUL_ID = -1,
-  OSL_CLOSURE_ADD_ID = -2,
-
-  OSL_CLOSURE_NONE_ID = 0,
-
-#define OSL_CLOSURE_STRUCT_BEGIN(Upper, lower) OSL_CLOSURE_##Upper##_ID,
-#include "closures_template.h"
-  OSL_CLOSURE_LAYER_ID,
-};
-
-struct OSLClosure {
-  OSLClosureType id;
-};
-
-struct ccl_align(8) OSLClosureMul : public OSLClosure {
-  packed_float3 weight;
-  const ccl_private OSLClosure *closure;
-};
-
-struct ccl_align(8) OSLClosureAdd : public OSLClosure {
-  const ccl_private OSLClosure *closureA;
-  const ccl_private OSLClosure *closureB;
-};
-
-struct ccl_align(8) OSLClosureComponent : public OSLClosure {
-  packed_float3 weight;
-};
-
-/* Globals */
-
-/* This structure is essentially a copy of OSL::ShaderGlobals, but with some of the
- * opaque pointers replaced with the types that we use for them and additional members
- * at the end.
- * As long as the layout matches (which is must in any case, in order for the OptiX OSL
- * code to work), this works fine since OSL doesn't do pointer arithmetic etc. on the
- * ShaderGlobals pointer that we give it. */
-struct ShaderGlobals {
-  /* This part of ShaderGlobals is shared with OSL's own struct, so the layout must match! */
-  packed_float3 P, dPdx, dPdy;
-  packed_float3 dPdz;
-  packed_float3 I, dIdx, dIdy;
-  packed_float3 N;
-  packed_float3 Ng;
-  float u, dudx, dudy;
-  float v, dvdx, dvdy;
-  packed_float3 dPdu, dPdv;
-  float time;
-  float dtime;
-  packed_float3 dPdtime;
-  packed_float3 Ps, dPsdx, dPsdy;
-
-  /* In OSL this is an opaque pointer named render-state. */
-  ccl_private ShaderData *sd;
-
-  /* In OSL this is an opaque pointer */
-  ccl_private OSLTraceData *tracedata;
-
-  /* In OSL this is an opaque pointer named `objdata`. */
-#ifdef __KERNEL_GPU__
-  ccl_private uint8_t *closure_pool;
-#else
-  const ThreadKernelGlobalsCPU *kg;
-#endif
-
-  void *context;
-  void *shadingStateUniform;
-  int thread_index;
-
-  /* We use this to encode the path state on GPUs.
-   * Zero means no state, positive means path_state, negative means shadow_path_state.
-   * On CPU, we use pointers in the Cycles-specific section below. */
-  int shade_index;
-
-  void *renderer;
-  ccl_private void *object2common;
-  ccl_private void *shader2common;
-  ccl_private OSLClosure *Ci;
-  float surfacearea;
-  int raytype;
-  int flipHandedness;
-  int backfacing;
-
-  /* This part is Cycles-specific and ignored by OSL itself. */
-#ifndef __KERNEL_GPU__
-  const struct IntegratorStateCPU *path_state;
-  const struct IntegratorShadowStateCPU *shadow_path_state;
-#endif
-};
-
-struct OSLNoiseOptions {};
-
-struct OSLTextureOptions {};
-
-#define OSL_TEXTURE_HANDLE_TYPE_IES ((uintptr_t)0x2 << 30)
-#define OSL_TEXTURE_HANDLE_TYPE_SVM ((uintptr_t)0x1 << 30)
-#define OSL_TEXTURE_HANDLE_TYPE_AO_OR_BEVEL ((uintptr_t)0x3 << 30)
-
-#define OSL_TEXTURE_HANDLE_TYPE(handle) \
-  ((unsigned int)((uintptr_t)(handle) & ((uintptr_t)0x3 << 30)))
-#define OSL_TEXTURE_HANDLE_SLOT(handle) \
-  ((unsigned int)((uintptr_t)(handle) & ((uintptr_t)0x3FFFFFFF)))
-
-CCL_NAMESPACE_END

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

@@ -1,53 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "util/hash.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Linear Congruential Generator */
-
-/* This is templated to handle multiple address spaces on Metal. */
-template<class T> ccl_device uint lcg_step_uint(T rng)
-{
-  /* implicit mod 2^32 */
-  *rng = (1103515245 * (*rng) + 12345);
-  return *rng;
-}
-
-/* This is templated to handle multiple address spaces on Metal. */
-template<class T> ccl_device float lcg_step_float(T rng)
-{
-  /* implicit mod 2^32 */
-  *rng = (1103515245 * (*rng) + 12345);
-  return (float)*rng * (1.0f / (float)0xFFFFFFFF);
-}
-
-template<class T> ccl_device float3 lcg_step_float3(T rng)
-{
-  /* Make sure the random numbers are evaluated in order. */
-  const float rand_x = lcg_step_float(rng);
-  const float rand_y = lcg_step_float(rng);
-  const float rand_z = lcg_step_float(rng);
-  return make_float3(rand_x, rand_y, rand_z);
-}
-
-ccl_device uint lcg_init(const uint seed)
-{
-  uint rng = seed;
-  lcg_step_uint(&rng);
-  return rng;
-}
-
-ccl_device_inline uint lcg_state_init(const uint rng_hash,
-                                      const uint rng_offset,
-                                      const uint sample,
-                                      const uint scramble)
-{
-  return hash_uint3(rng_hash ^ scramble, rng_offset, sample);
-}
-
-CCL_NAMESPACE_END

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

@@ -1,251 +0,0 @@
-/* SPDX-FileCopyrightText: 2009-2010 Sony Pictures Imageworks Inc., et al. All Rights Reserved.
- * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Adapted code from Open Shading Language. */
-
-#pragma once
-
-#include "util/math.h"
-#include "util/projection.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Distribute 2D uniform random samples on [0, 1] over unit disk [-1, 1], with concentric mapping
- * to better preserve stratification for some RNG sequences. */
-ccl_device float2 sample_uniform_disk(const float2 rand)
-{
-  float phi;
-  float r;
-  const float a = 2.0f * rand.x - 1.0f;
-  const float b = 2.0f * rand.y - 1.0f;
-
-  if (a == 0.0f && b == 0.0f) {
-    return zero_float2();
-  }
-
-  if (a * a > b * b) {
-    r = a;
-    phi = M_PI_4_F * (b / a);
-  }
-  else {
-    r = b;
-    phi = M_PI_2_F - M_PI_4_F * (a / b);
-  }
-
-  return polar_to_cartesian(r, phi);
-}
-
-/* return an orthogonal tangent and bitangent given a normal and tangent that
- * may not be exactly orthogonal */
-ccl_device void make_orthonormals_tangent(const float3 N,
-                                          const float3 T,
-                                          ccl_private float3 *a,
-                                          ccl_private float3 *b)
-{
-  *b = normalize(cross(N, T));
-  *a = cross(*b, N);
-}
-
-ccl_device void make_orthonormals_safe_tangent(const float3 N,
-                                               const float3 T,
-                                               ccl_private float3 *a,
-                                               ccl_private float3 *b)
-{
-  *b = safe_normalize(cross(N, T));
-  if (len_squared(*b) < 0.99f) {
-    /* Normalization failed, so fall back to basic orthonormals. */
-    make_orthonormals(N, a, b);
-  }
-  else {
-    *a = cross(*b, N);
-  }
-}
-
-/* sample direction with cosine weighted distributed in hemisphere */
-ccl_device_inline void sample_cos_hemisphere(const float3 N,
-                                             const float2 rand_in,
-                                             ccl_private float3 *wo,
-                                             ccl_private float *pdf)
-{
-  const float2 rand = sample_uniform_disk(rand_in);
-  const float costheta = safe_sqrtf(1.0f - len_squared(rand));
-
-  float3 T;
-  float3 B;
-  make_orthonormals(N, &T, &B);
-  *wo = rand.x * T + rand.y * B + costheta * N;
-  *pdf = costheta * M_1_PI_F;
-}
-
-ccl_device_inline float pdf_cos_hemisphere(const float3 N, const float3 D)
-{
-  const float cos_theta = dot(N, D);
-  return cos_theta > 0 ? cos_theta * M_1_PI_F : 0.0f;
-}
-
-/* sample direction uniformly distributed in hemisphere */
-ccl_device_inline void sample_uniform_hemisphere(const float3 N,
-                                                 const float2 rand,
-                                                 ccl_private float3 *wo,
-                                                 ccl_private float *pdf)
-{
-  float2 xy = sample_uniform_disk(rand);
-  const float z = 1.0f - len_squared(xy);
-
-  xy *= safe_sqrtf(z + 1.0f);
-
-  float3 T;
-  float3 B;
-  make_orthonormals(N, &T, &B);
-
-  *wo = xy.x * T + xy.y * B + z * N;
-  *pdf = M_1_2PI_F;
-}
-
-ccl_device_inline float pdf_uniform_cone(const float3 N, const float3 D, const float angle)
-{
-  const float z = precise_angle(N, D);
-  if (z < angle) {
-    return M_1_2PI_F / one_minus_cos(angle);
-  }
-  return 0.0f;
-}
-
-/* Uniformly sample a direction in a cone of given angle around `N`. Use concentric mapping to
- * better preserve stratification. Return the angle between `N` and the sampled direction as
- * `cos_theta`.
- * Pass `1 - cos(angle)` as argument instead of `angle` to alleviate precision issues at small
- * angles (see sphere light for reference). */
-ccl_device_inline float3 sample_uniform_cone(const float3 N,
-                                             const float one_minus_cos_angle,
-                                             const float2 rand,
-                                             ccl_private float *cos_theta,
-                                             ccl_private float *pdf)
-{
-  if (one_minus_cos_angle > 0) {
-    /* Remap radius to get a uniform distribution w.r.t. solid angle on the cone.
-     * The logic to derive this mapping is as follows:
-     *
-     * Sampling a cone is comparable to sampling the hemisphere, we just restrict theta. Therefore,
-     * the same trick of first sampling the unit disk and the projecting the result up towards the
-     * hemisphere by calculating the appropriate z coordinate still works.
-     *
-     * However, by itself this results in cosine-weighted hemisphere sampling, so we need some kind
-     * of remapping. Cosine-weighted hemisphere and uniform cone sampling have the same conditional
-     * PDF for phi (both are constant), so we only need to think about theta, which corresponds
-     * directly to the radius.
-     *
-     * To find this mapping, we consider the simplest sampling strategies for cosine-weighted
-     * hemispheres and uniform cones. In both, phi is chosen as `2pi * random()`. For the former,
-     * `r_disk(rand) = sqrt(rand)`. This is just naive disk sampling, since the projection to the
-     * hemisphere doesn't change the radius.
-     * For the latter, `r_cone(rand) = sin_from_cos(mix(cos_angle, 1, rand))`.
-     *
-     * So, to remap, we just invert r_disk `(-> rand(r_disk) = r_disk^2)` and insert it into
-     * r_cone: `r_cone(r_disk) = r_cone(rand(r_disk)) = sin_from_cos(mix(cos_angle, 1, r_disk^2))`.
-     * In practice, we need to replace `rand` with `1 - rand` to preserve the stratification,
-     * but since it's uniform, that's fine. */
-    float2 xy = sample_uniform_disk(rand);
-    const float r2 = len_squared(xy);
-
-    /* Equivalent to `mix(cos_angle, 1.0f, 1.0f - r2)`. */
-    *cos_theta = 1.0f - r2 * one_minus_cos_angle;
-
-    /* Remap disk radius to cone radius, equivalent to `xy *= sin_theta / sqrt(r2)`. */
-    xy *= safe_sqrtf(one_minus_cos_angle * (2.0f - one_minus_cos_angle * r2));
-
-    *pdf = M_1_2PI_F / one_minus_cos_angle;
-
-    float3 T;
-    float3 B;
-    make_orthonormals(N, &T, &B);
-    return xy.x * T + xy.y * B + *cos_theta * N;
-  }
-
-  *cos_theta = 1.0f;
-  *pdf = 1.0f;
-
-  return N;
-}
-
-/* sample uniform point on the surface of a sphere */
-ccl_device float3 sample_uniform_sphere(const float2 rand)
-{
-  const float z = 1.0f - 2.0f * rand.x;
-  const float r = sin_from_cos(z);
-  const float phi = M_2PI_F * rand.y;
-
-  return make_float3(polar_to_cartesian(r, phi), z);
-}
-
-/* sample point in unit polygon with given number of corners and rotation */
-ccl_device float2 regular_polygon_sample(const float corners, float rotation, const float2 rand)
-{
-  float u = rand.x;
-  float v = rand.y;
-
-  /* sample corner number and reuse u */
-  const float corner = floorf(u * corners);
-  u = u * corners - corner;
-
-  /* uniform sampled triangle weights */
-  u = sqrtf(u);
-  v = v * u;
-  u = 1.0f - u;
-
-  /* point in triangle */
-  const float angle = M_PI_F / corners;
-  const float2 p = make_float2((u + v) * cosf(angle), (u - v) * sinf(angle));
-
-  /* rotate */
-  rotation += corner * 2.0f * angle;
-
-  const float cr = cosf(rotation);
-  const float sr = sinf(rotation);
-
-  return make_float2(cr * p.x - sr * p.y, sr * p.x + cr * p.y);
-}
-
-/* Generate random variable x following geometric distribution p(x) = r * (1 - r)^x, 0 <= p <= 1.
- * Also compute the probability mass function pmf.
- * The sampled order is truncated at `cut_off`. */
-ccl_device_inline int sample_geometric_distribution(const float rand,
-                                                    const float r,
-                                                    ccl_private float &pmf,
-                                                    const int cut_off = INT_MAX)
-{
-  const int n = min(int(floorf(logf(rand) / logf(1.0f - r))), cut_off);
-  pmf = (n == cut_off) ? powf(1.0f - r, n) : r * powf(1.0f - r, n);
-  return n;
-}
-
-/* Generate random variable x following exponential distribution p(x) = lambda * exp(-lambda * x),
- * where lambda > 0 is the rate parameter. */
-ccl_device_inline float sample_exponential_distribution(const float rand, const float lambda)
-{
-  return -logf(1.0f - rand) / lambda;
-}
-
-/* Generate random variable x following bounded exponential distribution
- * p(x) = lambda * exp(-lambda * x) / (exp(-lambda * t.min) - exp(-lambda * t.max)),
- * where lambda > 0 is the rate parameter.
- * The generated sample lies in (t.min, t.max). */
-ccl_device_inline float sample_exponential_distribution(const float rand,
-                                                        const float lambda,
-                                                        const Interval<float> t)
-{
-  const float attenuation = 1.0f - expf(lambda * (t.min - t.max));
-  return clamp(t.min - logf(1.0f - rand * attenuation) / lambda, t.min, t.max);
-}
-
-ccl_device_inline Spectrum pdf_exponential_distribution(const float x,
-                                                        const Spectrum lambda,
-                                                        const Interval<float> t)
-{
-  const Spectrum attenuation = exp(-lambda * t.min) - exp(-lambda * t.max);
-  return safe_divide(lambda * exp(-lambda * clamp(x, t.min, t.max)), attenuation);
-}
-
-CCL_NAMESPACE_END

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

@@ -1,41 +0,0 @@
-/* SPDX-FileCopyrightText: 2009-2010 Sony Pictures Imageworks Inc., et al. All Rights Reserved.
- * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Adapted code from Open Shading Language. */
-
-#pragma once
-
-#include "util/defines.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Multiple importance sampling utilities. */
-
-ccl_device float balance_heuristic(const float a, const float b)
-{
-  return (a) / (a + b);
-}
-
-ccl_device float balance_heuristic_3(const float a, const float b, float c)
-{
-  return (a) / (a + b + c);
-}
-
-ccl_device float power_heuristic(const float a, const float b)
-{
-  return (a * a) / (a * a + b * b);
-}
-
-ccl_device float power_heuristic_3(const float a, const float b, float c)
-{
-  return (a * a) / (a * a + b * b + c * c);
-}
-
-ccl_device float max_heuristic(const float a, const float b)
-{
-  return (a > b) ? 1.0f : 0.0f;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,188 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/globals.h"
-
-#include "kernel/sample/sobol_burley.h"
-#include "kernel/sample/tabulated_sobol.h"
-
-#include "util/hash.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Pseudo random numbers, uncomment this for debugging correlations. Only run
- * this single threaded on a CPU for repeatable results. */
-// #define __DEBUG_CORRELATION__
-
-/*
- * The `path_rng_*()` functions below use a shuffled scrambled Sobol
- * sequence to generate their samples.  Sobol samplers have a property
- * that is worth being aware of when choosing how to use the sample
- * dimensions:
- *
- * 1. In general, earlier sets of dimensions are better stratified.  So
- *    prefer e.g. x,y over y,z over z,w for the things that are most
- *    important to sample well.
- * 2. As a rule of thumb, dimensions that are closer to each other are
- *    better stratified than dimensions that are far.  So prefer e.g.
- *    x,y over x,z.
- */
-
-ccl_device_forceinline uint3 blue_noise_indexing(KernelGlobals kg,
-                                                 uint pixel_index,
-                                                 const uint sample)
-{
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_SOBOL_BURLEY) {
-    /* One sequence per pixel, using the length mask optimization. */
-    return make_uint3(sample, pixel_index, kernel_data.integrator.sobol_index_mask);
-  }
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_PURE) {
-    /* For blue-noise samples, we use a single sequence (seed 0) with each pixel receiving
-     * a section of it.
-     * The total length is expected to get very large (effectively pixel count times sample count),
-     * so we don't use the length mask optimization here. */
-    pixel_index *= kernel_data.integrator.blue_noise_sequence_length;
-    return make_uint3(sample + pixel_index, 0, 0xffffffff);
-  }
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_FIRST) {
-    /* The "first" pattern uses a 1SPP blue-noise sequence for the first sample, and a separate
-     * N-1 SPP sequence for the remaining pixels. The purpose of this is to get blue-noise
-     * properties during viewport navigation, which will generally use 1 SPP.
-     * Unfortunately using just the first sample of a full blue-noise sequence doesn't give
-     * its benefits, so we combine the two as a tradeoff between quality at 1 SPP and full SPP. */
-    if (sample == 0) {
-      return make_uint3(pixel_index, 0x0cd0519f, 0xffffffff);
-    }
-    pixel_index *= kernel_data.integrator.blue_noise_sequence_length;
-    return make_uint3((sample - 1) + pixel_index, 0, 0xffffffff);
-  }
-  kernel_assert(false);
-  return make_uint3(0, 0, 0);
-}
-
-ccl_device_forceinline float path_rng_1D(KernelGlobals kg,
-                                         const uint rng_pixel,
-                                         const uint sample,
-                                         const int dimension)
-{
-#ifdef __DEBUG_CORRELATION__
-  return (float)drand48();
-#endif
-
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_TABULATED_SOBOL) {
-    return tabulated_sobol_sample_1D(kg, sample, rng_pixel, dimension);
-  }
-
-  const uint3 index = blue_noise_indexing(kg, rng_pixel, sample);
-  return sobol_burley_sample_1D(index.x, dimension, index.y, index.z);
-}
-
-ccl_device_forceinline float2 path_rng_2D(KernelGlobals kg,
-                                          const uint rng_pixel,
-                                          const int sample,
-                                          const int dimension)
-{
-#ifdef __DEBUG_CORRELATION__
-  return make_float2((float)drand48(), (float)drand48());
-#endif
-
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_TABULATED_SOBOL) {
-    return tabulated_sobol_sample_2D(kg, sample, rng_pixel, dimension);
-  }
-
-  const uint3 index = blue_noise_indexing(kg, rng_pixel, sample);
-  return sobol_burley_sample_2D(index.x, dimension, index.y, index.z);
-}
-
-ccl_device_forceinline float3 path_rng_3D(KernelGlobals kg,
-                                          const uint rng_pixel,
-                                          const int sample,
-                                          const int dimension)
-{
-#ifdef __DEBUG_CORRELATION__
-  return make_float3((float)drand48(), (float)drand48(), (float)drand48());
-#endif
-
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_TABULATED_SOBOL) {
-    return tabulated_sobol_sample_3D(kg, sample, rng_pixel, dimension);
-  }
-
-  const uint3 index = blue_noise_indexing(kg, rng_pixel, sample);
-  return sobol_burley_sample_3D(index.x, dimension, index.y, index.z);
-}
-
-ccl_device_forceinline float4 path_rng_4D(KernelGlobals kg,
-                                          const uint rng_pixel,
-                                          const int sample,
-                                          const int dimension)
-{
-#ifdef __DEBUG_CORRELATION__
-  return make_float4((float)drand48(), (float)drand48(), (float)drand48(), (float)drand48());
-#endif
-
-  if (kernel_data.integrator.sampling_pattern == SAMPLING_PATTERN_TABULATED_SOBOL) {
-    return tabulated_sobol_sample_4D(kg, sample, rng_pixel, dimension);
-  }
-
-  const uint3 index = blue_noise_indexing(kg, rng_pixel, sample);
-  return sobol_burley_sample_4D(index.x, dimension, index.y, index.z);
-}
-
-ccl_device_inline uint path_rng_pixel_init(KernelGlobals kg,
-                                           const int /*sample*/,
-                                           const int x,
-                                           const int y)
-{
-  const uint pattern = kernel_data.integrator.sampling_pattern;
-  if (pattern == SAMPLING_PATTERN_TABULATED_SOBOL || pattern == SAMPLING_PATTERN_SOBOL_BURLEY) {
-
-    /* The white-noise samplers use a random per-pixel hash to generate independent sequences. */
-    return hash_iqnt2d(x, y) ^ kernel_data.integrator.seed;
-  }
-
-  /* The blue-noise samplers use a single sequence for all pixels, but offset the index within
-   * the sequence for each pixel. We use a hierarchically shuffled 2D morton curve to determine
-   * each pixel's offset along the sequence.
-   *
-   * Based on:
-   * https://psychopath.io/post/2022_07_24_owen_scrambling_based_dithered_blue_noise_sampling.
-   *
-   * TODO(lukas): Use a precomputed Hilbert curve to avoid directionality bias in the noise
-   * distribution. We can just precompute a small-ish tile and repeat it in morton code order.
-   */
-  return nested_uniform_scramble_base4(morton2d(x, y), kernel_data.integrator.seed);
-}
-
-/**
- * Splits samples into two different classes, A and B, which can be
- * compared for variance estimation.
- */
-ccl_device_inline bool sample_is_class_A(const int pattern, const int sample)
-{
-#if 0
-  if (!(pattern == SAMPLING_PATTERN_TABULATED_SOBOL || pattern == SAMPLING_PATTERN_SOBOL_BURLEY)) {
-    /* Fallback: assign samples randomly.
-     * This is guaranteed to work "okay" for any sampler, but isn't good.
-     * (NOTE: the seed constant is just a random number to guard against
-     * possible interactions with other uses of the hash. There's nothing
-     * special about it.)
-     */
-    return hash_hp_seeded_uint(sample, 0xa771f873) & 1;
-  }
-#else
-  (void)pattern;
-#endif
-
-  /* This follows the approach from section 10.2.1 of "Progressive
-   * Multi-Jittered Sample Sequences" by Christensen et al., but
-   * implemented with efficient bit-fiddling.
-   *
-   * This approach also turns out to work equally well with Owen
-   * scrambled and shuffled Sobol (see https://developer.blender.org/D15746#429471).
-   */
-  return popcount(uint(sample) & 0xaaaaaaaa) & 1;
-}
-CCL_NAMESPACE_END