@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,370 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/fractal_noise.h"
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* The following offset functions generate random offsets to be added to texture
- * coordinates to act as a seed since the noise functions don't have seed values.
- * A seed value is needed for generating distortion textures and color outputs.
- * The offset's components are in the range [100, 200], not too high to cause
- * bad precision and not too small to be noticeable. We use float seed because
- * OSL only support float hashes.
- */
-
-ccl_device_inline float random_float_offset(const float seed)
-{
-  return 100.0f + hash_float_to_float(seed) * 100.0f;
-}
-
-ccl_device_inline float2 random_float2_offset(const float seed)
-{
-  return make_float2(100.0f + hash_float2_to_float(make_float2(seed, 0.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 1.0f)) * 100.0f);
-}
-
-ccl_device_inline float3 random_float3_offset(const float seed)
-{
-  return make_float3(100.0f + hash_float2_to_float(make_float2(seed, 0.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 1.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 2.0f)) * 100.0f);
-}
-
-ccl_device_inline float4 random_float4_offset(const float seed)
-{
-  return make_float4(100.0f + hash_float2_to_float(make_float2(seed, 0.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 1.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 2.0f)) * 100.0f,
-                     100.0f + hash_float2_to_float(make_float2(seed, 3.0f)) * 100.0f);
-}
-
-template<typename T>
-ccl_device float noise_select(T p,
-                              const float detail,
-                              const float roughness,
-                              const float lacunarity,
-                              const float offset,
-                              const float gain,
-                              const int type,
-                              bool normalize)
-{
-  switch ((NodeNoiseType)type) {
-    case NODE_NOISE_MULTIFRACTAL: {
-      return noise_multi_fractal(p, detail, roughness, lacunarity);
-    }
-    case NODE_NOISE_FBM: {
-      return noise_fbm(p, detail, roughness, lacunarity, normalize);
-    }
-    case NODE_NOISE_HYBRID_MULTIFRACTAL: {
-      return noise_hybrid_multi_fractal(p, detail, roughness, lacunarity, offset, gain);
-    }
-    case NODE_NOISE_RIDGED_MULTIFRACTAL: {
-      return noise_ridged_multi_fractal(p, detail, roughness, lacunarity, offset, gain);
-    }
-    case NODE_NOISE_HETERO_TERRAIN: {
-      return noise_hetero_terrain(p, detail, roughness, lacunarity, offset);
-    }
-    default: {
-      kernel_assert(0);
-      return 0.0;
-    }
-  }
-}
-
-ccl_device void noise_texture_1d(const float co,
-                                 const float detail,
-                                 const float roughness,
-                                 const float lacunarity,
-                                 const float offset,
-                                 const float gain,
-                                 const float distortion,
-                                 const int type,
-                                 bool normalize,
-                                 bool color_is_needed,
-                                 ccl_private float *value,
-                                 ccl_private float3 *color)
-{
-  float p = co;
-  if (distortion != 0.0f) {
-    p += snoise_1d(p + random_float_offset(0.0f)) * distortion;
-  }
-
-  *value = noise_select(p, detail, roughness, lacunarity, offset, gain, type, normalize);
-  if (color_is_needed) {
-    *color = make_float3(*value,
-                         noise_select(p + random_float_offset(1.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize),
-                         noise_select(p + random_float_offset(2.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize));
-  }
-}
-
-ccl_device void noise_texture_2d(const float2 co,
-                                 const float detail,
-                                 const float roughness,
-                                 const float lacunarity,
-                                 const float offset,
-                                 const float gain,
-                                 const float distortion,
-                                 const int type,
-                                 const bool normalize,
-                                 const bool color_is_needed,
-                                 ccl_private float *value,
-                                 ccl_private float3 *color)
-{
-  float2 p = co;
-  if (distortion != 0.0f) {
-    p += make_float2(snoise_2d(p + random_float2_offset(0.0f)) * distortion,
-                     snoise_2d(p + random_float2_offset(1.0f)) * distortion);
-  }
-
-  *value = noise_select(p, detail, roughness, lacunarity, offset, gain, type, normalize);
-  if (color_is_needed) {
-    *color = make_float3(*value,
-                         noise_select(p + random_float2_offset(2.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize),
-                         noise_select(p + random_float2_offset(3.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize));
-  }
-}
-
-ccl_device void noise_texture_3d(const float3 co,
-                                 const float detail,
-                                 const float roughness,
-                                 const float lacunarity,
-                                 const float offset,
-                                 const float gain,
-                                 const float distortion,
-                                 const int type,
-                                 const bool normalize,
-                                 const bool color_is_needed,
-                                 ccl_private float *value,
-                                 ccl_private float3 *color)
-{
-  float3 p = co;
-  if (distortion != 0.0f) {
-    p += make_float3(snoise_3d(p + random_float3_offset(0.0f)) * distortion,
-                     snoise_3d(p + random_float3_offset(1.0f)) * distortion,
-                     snoise_3d(p + random_float3_offset(2.0f)) * distortion);
-  }
-
-  *value = noise_select(p, detail, roughness, lacunarity, offset, gain, type, normalize);
-  if (color_is_needed) {
-    *color = make_float3(*value,
-                         noise_select(p + random_float3_offset(3.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize),
-                         noise_select(p + random_float3_offset(4.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize));
-  }
-}
-
-ccl_device void noise_texture_4d(const float4 co,
-                                 const float detail,
-                                 const float roughness,
-                                 const float lacunarity,
-                                 const float offset,
-                                 const float gain,
-                                 const float distortion,
-                                 const int type,
-                                 const bool normalize,
-                                 const bool color_is_needed,
-                                 ccl_private float *value,
-                                 ccl_private float3 *color)
-{
-  float4 p = co;
-  if (distortion != 0.0f) {
-    p += make_float4(snoise_4d(p + random_float4_offset(0.0f)) * distortion,
-                     snoise_4d(p + random_float4_offset(1.0f)) * distortion,
-                     snoise_4d(p + random_float4_offset(2.0f)) * distortion,
-                     snoise_4d(p + random_float4_offset(3.0f)) * distortion);
-  }
-
-  *value = noise_select(p, detail, roughness, lacunarity, offset, gain, type, normalize);
-  if (color_is_needed) {
-    *color = make_float3(*value,
-                         noise_select(p + random_float4_offset(4.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize),
-                         noise_select(p + random_float4_offset(5.0f),
-                                      detail,
-                                      roughness,
-                                      lacunarity,
-                                      offset,
-                                      gain,
-                                      type,
-                                      normalize));
-  }
-}
-
-ccl_device_noinline int svm_node_tex_noise(KernelGlobals kg,
-                                           ccl_private float *stack,
-                                           const uint offsets1,
-                                           const uint offsets2,
-                                           const uint offsets3,
-                                           int node_offset)
-{
-  uint vector_stack_offset;
-  uint w_stack_offset;
-  uint scale_stack_offset;
-  uint detail_stack_offset;
-  uint roughness_stack_offset;
-  uint lacunarity_stack_offset;
-  uint offset_stack_offset;
-  uint gain_stack_offset;
-  uint distortion_stack_offset;
-  uint value_stack_offset;
-  uint color_stack_offset;
-
-  svm_unpack_node_uchar4(
-      offsets1, &vector_stack_offset, &w_stack_offset, &scale_stack_offset, &detail_stack_offset);
-  svm_unpack_node_uchar4(offsets2,
-                         &roughness_stack_offset,
-                         &lacunarity_stack_offset,
-                         &offset_stack_offset,
-                         &gain_stack_offset);
-  svm_unpack_node_uchar3(
-      offsets3, &distortion_stack_offset, &value_stack_offset, &color_stack_offset);
-
-  const uint4 defaults1 = read_node(kg, &node_offset);
-  const uint4 defaults2 = read_node(kg, &node_offset);
-  const uint4 properties = read_node(kg, &node_offset);
-
-  const uint dimensions = properties.x;
-  const uint type = properties.y;
-  const uint normalize = properties.z;
-
-  float3 vector = stack_load_float3(stack, vector_stack_offset);
-  float w = stack_load_float_default(stack, w_stack_offset, defaults1.x);
-  const float scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y);
-  float detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z);
-  float roughness = stack_load_float_default(stack, roughness_stack_offset, defaults1.w);
-  const float lacunarity = stack_load_float_default(stack, lacunarity_stack_offset, defaults2.x);
-  const float offset = stack_load_float_default(stack, offset_stack_offset, defaults2.y);
-  const float gain = stack_load_float_default(stack, gain_stack_offset, defaults2.z);
-  const float distortion = stack_load_float_default(stack, distortion_stack_offset, defaults2.w);
-
-  detail = clamp(detail, 0.0f, 15.0f);
-  roughness = fmaxf(roughness, 0.0f);
-
-  vector *= scale;
-  w *= scale;
-
-  float value;
-  float3 color;
-  switch (dimensions) {
-    case 1:
-      noise_texture_1d(w,
-                       detail,
-                       roughness,
-                       lacunarity,
-                       offset,
-                       gain,
-                       distortion,
-                       type,
-                       normalize,
-                       stack_valid(color_stack_offset),
-                       &value,
-                       &color);
-      break;
-    case 2:
-      noise_texture_2d(make_float2(vector.x, vector.y),
-                       detail,
-                       roughness,
-                       lacunarity,
-                       offset,
-                       gain,
-                       distortion,
-                       type,
-                       normalize,
-                       stack_valid(color_stack_offset),
-                       &value,
-                       &color);
-      break;
-    case 3:
-      noise_texture_3d(vector,
-                       detail,
-                       roughness,
-                       lacunarity,
-                       offset,
-                       gain,
-                       distortion,
-                       type,
-                       normalize,
-                       stack_valid(color_stack_offset),
-                       &value,
-                       &color);
-      break;
-    case 4:
-      noise_texture_4d(make_float4(vector, w),
-                       detail,
-                       roughness,
-                       lacunarity,
-                       offset,
-                       gain,
-                       distortion,
-                       type,
-                       normalize,
-                       stack_valid(color_stack_offset),
-                       &value,
-                       &color);
-      break;
-    default:
-      kernel_assert(0);
-  }
-
-  if (stack_valid(value_stack_offset)) {
-    stack_store_float(stack, value_stack_offset, value);
-  }
-  if (stack_valid(color_stack_offset)) {
-    stack_store_float3(stack, color_stack_offset, color);
-  }
-  return node_offset;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,38 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device_noinline int svm_node_normal(KernelGlobals kg,
-                                        ccl_private float *stack,
-                                        const uint in_normal_offset,
-                                        const uint out_normal_offset,
-                                        const uint out_dot_offset,
-                                        int offset)
-{
-  /* read extra data */
-  const uint4 node1 = read_node(kg, &offset);
-  const float3 normal = stack_load_float3(stack, in_normal_offset);
-
-  float3 direction;
-  direction.x = __int_as_float(node1.x);
-  direction.y = __int_as_float(node1.y);
-  direction.z = __int_as_float(node1.z);
-  direction = normalize(direction);
-
-  if (stack_valid(out_normal_offset)) {
-    stack_store_float3(stack, out_normal_offset, direction);
-  }
-
-  if (stack_valid(out_dot_offset)) {
-    stack_store_float(stack, out_dot_offset, dot(direction, normalize(normal)));
-  }
-  return offset;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,81 +0,0 @@
-/* SPDX-FileCopyrightText: 2024-2025 Blender Authors
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-CCL_NAMESPACE_BEGIN
-
-/* Define macro flags for code adaption. */
-#define ADAPT_TO_SVM
-
-/* The rounded polygon calculation functions are defined in radial_tiling_shared.h. */
-#include "radial_tiling_shared.h"
-
-/* Undefine macro flags used for code adaption. */
-#undef ADAPT_TO_SVM
-
-struct RoundedPolygonStackOffsets {
-  uint vector;
-  uint r_gon_sides;
-  uint r_gon_roundness;
-  uint segment_coordinates;
-  uint segment_id;
-  uint max_unit_parameter;
-  uint x_axis_A_angle_bisector;
-};
-
-template<uint node_feature_mask>
-ccl_device_noinline int svm_node_radial_tiling(ccl_private float *stack, uint4 node, int offset)
-{
-  RoundedPolygonStackOffsets so;
-
-  uint normalize_r_gon_parameter = node.y;
-
-  svm_unpack_node_uchar4(
-      node.z, &(so.vector), &(so.r_gon_sides), &(so.r_gon_roundness), &(so.segment_coordinates));
-  svm_unpack_node_uchar3(
-      node.w, &(so.segment_id), &(so.max_unit_parameter), &(so.x_axis_A_angle_bisector));
-
-  bool calculate_r_gon_parameter_field = stack_valid(so.segment_coordinates);
-  bool calculate_segment_id = stack_valid(so.segment_id);
-  bool calculate_max_unit_parameter = stack_valid(so.max_unit_parameter);
-  bool calculate_x_axis_A_angle_bisector = stack_valid(so.x_axis_A_angle_bisector);
-
-  float3 coord = stack_load_float3(stack, so.vector);
-  float r_gon_sides = stack_load_float(stack, so.r_gon_sides);
-  float r_gon_roundness = stack_load_float(stack, so.r_gon_roundness);
-
-  if (calculate_r_gon_parameter_field || calculate_max_unit_parameter ||
-      calculate_x_axis_A_angle_bisector)
-  {
-    float4 out_variables = calculate_out_variables(calculate_r_gon_parameter_field,
-                                                   calculate_max_unit_parameter,
-                                                   normalize_r_gon_parameter,
-                                                   fmaxf(r_gon_sides, 2.0f),
-                                                   clamp(r_gon_roundness, 0.0f, 1.0f),
-                                                   make_float2(coord.x, coord.y));
-
-    if (calculate_r_gon_parameter_field) {
-      stack_store_float3(
-          stack, so.segment_coordinates, make_float3(out_variables.y, out_variables.x, 0.0f));
-    }
-    if (calculate_max_unit_parameter) {
-      stack_store_float(stack, so.max_unit_parameter, out_variables.z);
-    }
-    if (calculate_x_axis_A_angle_bisector) {
-      stack_store_float(stack, so.x_axis_A_angle_bisector, out_variables.w);
-    }
-  }
-
-  if (calculate_segment_id) {
-    stack_store_float(
-        stack,
-        so.segment_id,
-        calculate_out_segment_id(fmaxf(r_gon_sides, 2.0f), make_float2(coord.x, coord.y)));
-  }
-
-  return offset;
-}
-
-CCL_NAMESPACE_END