@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,132 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Magic */
-
-ccl_device_noinline_cpu float3 svm_magic(const float3 p,
-                                         const float scale,
-                                         const int n,
-                                         float distortion)
-{
-  /*
-   * Prevent NaNs due to input p
-   * Sin and Cosine are periodic about [0 2*PI) so the following
-   * will yield a more accurate result. As it stops the input values
-   * going out of range for floats which caused a NaN. The
-   * calculation of (px + py + pz)*5 can cause an Inf when one or more
-   * values are very large the cos or sin of this results in a NaN
-   * It also addresses the case where one dimension is large relative
-   * to another which caused banding due to the loss of precision in the
-   * smaller value. This is due to the value in the -2*PI to 2*PI range
-   * effectively being lost due to floating point precision.
-   */
-  const float px = fmodf(p.x, M_2PI_F);
-  const float py = fmodf(p.y, M_2PI_F);
-  const float pz = fmodf(p.z, M_2PI_F);
-
-  float x = sinf((px + py + pz) * 5.0f * scale);
-  float y = cosf((-px + py - pz) * 5.0f * scale);
-  float z = -cosf((-px - py + pz) * 5.0f * scale);
-
-  if (n > 0) {
-    x *= distortion;
-    y *= distortion;
-    z *= distortion;
-    y = -cosf(x - y + z);
-    y *= distortion;
-
-    if (n > 1) {
-      x = cosf(x - y - z);
-      x *= distortion;
-
-      if (n > 2) {
-        z = sinf(-x - y - z);
-        z *= distortion;
-
-        if (n > 3) {
-          x = -cosf(-x + y - z);
-          x *= distortion;
-
-          if (n > 4) {
-            y = -sinf(-x + y + z);
-            y *= distortion;
-
-            if (n > 5) {
-              y = -cosf(-x + y + z);
-              y *= distortion;
-
-              if (n > 6) {
-                x = cosf(x + y + z);
-                x *= distortion;
-
-                if (n > 7) {
-                  z = sinf(x + y - z);
-                  z *= distortion;
-
-                  if (n > 8) {
-                    x = -cosf(-x - y + z);
-                    x *= distortion;
-
-                    if (n > 9) {
-                      y = -sinf(x - y + z);
-                      y *= distortion;
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (distortion != 0.0f) {
-    distortion *= 2.0f;
-    x /= distortion;
-    y /= distortion;
-    z /= distortion;
-  }
-
-  return make_float3(0.5f - x, 0.5f - y, 0.5f - z);
-}
-
-ccl_device_noinline int svm_node_tex_magic(KernelGlobals kg,
-                                           ccl_private float *stack,
-                                           const uint4 node,
-                                           int offset)
-{
-  uint depth;
-  uint scale_offset;
-  uint distortion_offset;
-  uint co_offset;
-  uint fac_offset;
-  uint color_offset;
-
-  svm_unpack_node_uchar3(node.y, &depth, &color_offset, &fac_offset);
-  svm_unpack_node_uchar3(node.z, &co_offset, &scale_offset, &distortion_offset);
-
-  const uint4 node2 = read_node(kg, &offset);
-  const float3 co = stack_load_float3(stack, co_offset);
-  const float scale = stack_load_float_default(stack, scale_offset, node2.x);
-  const float distortion = stack_load_float_default(stack, distortion_offset, node2.y);
-
-  const float3 color = svm_magic(co, scale, depth, distortion);
-
-  if (stack_valid(fac_offset)) {
-    stack_store_float(stack, fac_offset, average(color));
-  }
-  if (stack_valid(color_offset)) {
-    stack_store_float3(stack, color_offset, color);
-  }
-  return offset;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,164 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Map Range Node */
-
-ccl_device_inline float smootherstep(const float edge0, const float edge1, float x)
-{
-  x = clamp(safe_divide((x - edge0), (edge1 - edge0)), 0.0f, 1.0f);
-  return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f);
-}
-
-ccl_device_noinline int svm_node_map_range(KernelGlobals kg,
-                                           ccl_private float *stack,
-                                           const uint value_stack_offset,
-                                           const uint parameters_stack_offsets,
-                                           const uint results_stack_offsets,
-                                           int offset)
-{
-  uint from_min_stack_offset;
-  uint from_max_stack_offset;
-  uint to_min_stack_offset;
-  uint to_max_stack_offset;
-  uint type_stack_offset;
-  uint steps_stack_offset;
-  uint result_stack_offset;
-  svm_unpack_node_uchar4(parameters_stack_offsets,
-                         &from_min_stack_offset,
-                         &from_max_stack_offset,
-                         &to_min_stack_offset,
-                         &to_max_stack_offset);
-  svm_unpack_node_uchar3(
-      results_stack_offsets, &type_stack_offset, &steps_stack_offset, &result_stack_offset);
-
-  const uint4 defaults = read_node(kg, &offset);
-  const uint4 defaults2 = read_node(kg, &offset);
-
-  const float value = stack_load_float(stack, value_stack_offset);
-  const float from_min = stack_load_float_default(stack, from_min_stack_offset, defaults.x);
-  const float from_max = stack_load_float_default(stack, from_max_stack_offset, defaults.y);
-  const float to_min = stack_load_float_default(stack, to_min_stack_offset, defaults.z);
-  const float to_max = stack_load_float_default(stack, to_max_stack_offset, defaults.w);
-  const float steps = stack_load_float_default(stack, steps_stack_offset, defaults2.x);
-
-  float result;
-
-  if (from_max != from_min) {
-    float factor = value;
-    switch (type_stack_offset) {
-      default:
-      case NODE_MAP_RANGE_LINEAR:
-        factor = (value - from_min) / (from_max - from_min);
-        break;
-      case NODE_MAP_RANGE_STEPPED: {
-        factor = (value - from_min) / (from_max - from_min);
-        factor = (steps > 0.0f) ? floorf(factor * (steps + 1.0f)) / steps : 0.0f;
-        break;
-      }
-      case NODE_MAP_RANGE_SMOOTHSTEP: {
-        factor = (from_min > from_max) ? 1.0f - smoothstep(from_max, from_min, factor) :
-                                         smoothstep(from_min, from_max, factor);
-        break;
-      }
-      case NODE_MAP_RANGE_SMOOTHERSTEP: {
-        factor = (from_min > from_max) ? 1.0f - smootherstep(from_max, from_min, factor) :
-                                         smootherstep(from_min, from_max, factor);
-        break;
-      }
-    }
-    result = to_min + factor * (to_max - to_min);
-  }
-  else {
-    result = 0.0f;
-  }
-  stack_store_float(stack, result_stack_offset, result);
-  return offset;
-}
-
-ccl_device_noinline int svm_node_vector_map_range(ccl_private float *stack,
-                                                  const uint value_stack_offset,
-                                                  const uint parameters_stack_offsets,
-                                                  const uint results_stack_offsets,
-                                                  const int offset)
-{
-  uint from_min_stack_offset;
-  uint from_max_stack_offset;
-  uint to_min_stack_offset;
-  uint to_max_stack_offset;
-  uint steps_stack_offset;
-  uint clamp_stack_offset;
-  uint range_type_stack_offset;
-  uint result_stack_offset;
-  svm_unpack_node_uchar4(parameters_stack_offsets,
-                         &from_min_stack_offset,
-                         &from_max_stack_offset,
-                         &to_min_stack_offset,
-                         &to_max_stack_offset);
-  svm_unpack_node_uchar4(results_stack_offsets,
-                         &steps_stack_offset,
-                         &clamp_stack_offset,
-                         &range_type_stack_offset,
-                         &result_stack_offset);
-
-  const float3 value = stack_load_float3(stack, value_stack_offset);
-  const float3 from_min = stack_load_float3(stack, from_min_stack_offset);
-  const float3 from_max = stack_load_float3(stack, from_max_stack_offset);
-  const float3 to_min = stack_load_float3(stack, to_min_stack_offset);
-  const float3 to_max = stack_load_float3(stack, to_max_stack_offset);
-  const float3 steps = stack_load_float3(stack, steps_stack_offset);
-
-  const int type = range_type_stack_offset;
-  const int use_clamp = (type == NODE_MAP_RANGE_SMOOTHSTEP ||
-                         type == NODE_MAP_RANGE_SMOOTHERSTEP) ?
-                            0 :
-                            clamp_stack_offset;
-  float3 result;
-  float3 factor = value;
-  switch (range_type_stack_offset) {
-    default:
-    case NODE_MAP_RANGE_LINEAR:
-      factor = safe_divide((value - from_min), (from_max - from_min));
-      break;
-    case NODE_MAP_RANGE_STEPPED: {
-      factor = safe_divide((value - from_min), (from_max - from_min));
-      factor = make_float3((steps.x > 0.0f) ? floorf(factor.x * (steps.x + 1.0f)) / steps.x : 0.0f,
-                           (steps.y > 0.0f) ? floorf(factor.y * (steps.y + 1.0f)) / steps.y : 0.0f,
-                           (steps.z > 0.0f) ? floorf(factor.z * (steps.z + 1.0f)) / steps.z :
-                                              0.0f);
-      break;
-    }
-    case NODE_MAP_RANGE_SMOOTHSTEP: {
-      factor = safe_divide((value - from_min), (from_max - from_min));
-      factor = clamp(factor, zero_float3(), one_float3());
-      factor = (make_float3(3.0f, 3.0f, 3.0f) - 2.0f * factor) * (factor * factor);
-      break;
-    }
-    case NODE_MAP_RANGE_SMOOTHERSTEP: {
-      factor = safe_divide((value - from_min), (from_max - from_min));
-      factor = clamp(factor, zero_float3(), one_float3());
-      factor = factor * factor * factor * (factor * (factor * 6.0f - 15.0f) + 10.0f);
-      break;
-    }
-  }
-  result = to_min + factor * (to_max - to_min);
-  if (use_clamp > 0) {
-    result.x = (to_min.x > to_max.x) ? clamp(result.x, to_max.x, to_min.x) :
-                                       clamp(result.x, to_min.x, to_max.x);
-    result.y = (to_min.y > to_max.y) ? clamp(result.y, to_max.y, to_min.y) :
-                                       clamp(result.y, to_min.y, to_max.y);
-    result.z = (to_min.z > to_max.z) ? clamp(result.z, to_max.z, to_min.z) :
-                                       clamp(result.z, to_min.z, to_max.z);
-  }
-
-  stack_store_float3(stack, result_stack_offset, result);
-  return offset;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,74 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/mapping_util.h"
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-/* Mapping Node */
-
-ccl_device_noinline void svm_node_mapping(ccl_private float *stack,
-                                          const uint type,
-                                          const uint inputs_stack_offsets,
-                                          const uint result_stack_offset)
-{
-  uint vector_stack_offset;
-  uint location_stack_offset;
-  uint rotation_stack_offset;
-  uint scale_stack_offset;
-  svm_unpack_node_uchar4(inputs_stack_offsets,
-                         &vector_stack_offset,
-                         &location_stack_offset,
-                         &rotation_stack_offset,
-                         &scale_stack_offset);
-
-  const float3 vector = stack_load_float3(stack, vector_stack_offset);
-  const float3 location = stack_load_float3(stack, location_stack_offset);
-  const float3 rotation = stack_load_float3(stack, rotation_stack_offset);
-  const float3 scale = stack_load_float3(stack, scale_stack_offset);
-
-  const float3 result = svm_mapping((NodeMappingType)type, vector, location, rotation, scale);
-  stack_store_float3(stack, result_stack_offset, result);
-}
-
-/* Texture Mapping */
-
-ccl_device_noinline int svm_node_texture_mapping(KernelGlobals kg,
-                                                 ccl_private float *stack,
-                                                 const uint vec_offset,
-                                                 const uint out_offset,
-                                                 int offset)
-{
-  const float3 v = stack_load_float3(stack, vec_offset);
-
-  Transform tfm;
-  tfm.x = read_node_float(kg, &offset);
-  tfm.y = read_node_float(kg, &offset);
-  tfm.z = read_node_float(kg, &offset);
-
-  const float3 r = transform_point(&tfm, v);
-  stack_store_float3(stack, out_offset, r);
-  return offset;
-}
-
-ccl_device_noinline int svm_node_min_max(KernelGlobals kg,
-                                         ccl_private float *stack,
-                                         const uint vec_offset,
-                                         const uint out_offset,
-                                         int offset)
-{
-  const float3 v = stack_load_float3(stack, vec_offset);
-
-  const float3 mn = make_float3(read_node_float(kg, &offset));
-  const float3 mx = make_float3(read_node_float(kg, &offset));
-
-  const float3 r = min(max(mn, v), mx);
-  stack_store_float3(stack, out_offset, r);
-  return offset;
-}
-
-CCL_NAMESPACE_END

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

@@ -1,37 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/types.h"
-
-#include "util/math.h"
-#include "util/transform.h"
-#include "util/types.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device float3 svm_mapping(NodeMappingType type,
-                              const float3 vector,
-                              const float3 location,
-                              const float3 rotation,
-                              const float3 scale)
-{
-  const Transform rotationTransform = euler_to_transform(rotation);
-  switch (type) {
-    case NODE_MAPPING_TYPE_POINT:
-      return transform_direction(&rotationTransform, (vector * scale)) + location;
-    case NODE_MAPPING_TYPE_TEXTURE:
-      return safe_divide(transform_direction_transposed(&rotationTransform, (vector - location)),
-                         scale);
-    case NODE_MAPPING_TYPE_VECTOR:
-      return transform_direction(&rotationTransform, (vector * scale));
-    case NODE_MAPPING_TYPE_NORMAL:
-      return safe_normalize(transform_direction(&rotationTransform, safe_divide(vector, scale)));
-    default:
-      return make_float3(0.0f, 0.0f, 0.0f);
-  }
-}
-
-CCL_NAMESPACE_END

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

@@ -1,73 +0,0 @@
-/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#pragma once
-
-#include "kernel/svm/math_util.h"
-#include "kernel/svm/util.h"
-
-CCL_NAMESPACE_BEGIN
-
-ccl_device_noinline void svm_node_math(ccl_private float *stack,
-                                       const uint type,
-                                       const uint inputs_stack_offsets,
-                                       const uint result_stack_offset)
-{
-  uint a_stack_offset;
-  uint b_stack_offset;
-  uint c_stack_offset;
-  svm_unpack_node_uchar3(inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &c_stack_offset);
-
-  const float a = stack_load_float(stack, a_stack_offset);
-  const float b = stack_load_float(stack, b_stack_offset);
-  const float c = stack_load_float(stack, c_stack_offset);
-  const float result = svm_math((NodeMathType)type, a, b, c);
-
-  stack_store_float(stack, result_stack_offset, result);
-}
-
-ccl_device_noinline int svm_node_vector_math(KernelGlobals kg,
-                                             ccl_private float *stack,
-                                             const uint type,
-                                             const uint inputs_stack_offsets,
-                                             const uint outputs_stack_offsets,
-                                             int offset)
-{
-  uint value_stack_offset;
-  uint vector_stack_offset;
-  uint a_stack_offset;
-  uint b_stack_offset;
-  uint param1_stack_offset;
-  svm_unpack_node_uchar3(
-      inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &param1_stack_offset);
-  svm_unpack_node_uchar2(outputs_stack_offsets, &value_stack_offset, &vector_stack_offset);
-
-  const float3 a = stack_load_float3(stack, a_stack_offset);
-  const float3 b = stack_load_float3(stack, b_stack_offset);
-  float3 c = make_float3(0.0f, 0.0f, 0.0f);
-  const float param1 = stack_load_float(stack, param1_stack_offset);
-
-  float value;
-  float3 vector;
-
-  /* 3 Vector Operators */
-  if (type == NODE_VECTOR_MATH_WRAP || type == NODE_VECTOR_MATH_FACEFORWARD ||
-      type == NODE_VECTOR_MATH_MULTIPLY_ADD)
-  {
-    const uint4 extra_node = read_node(kg, &offset);
-    c = stack_load_float3(stack, extra_node.x);
-  }
-
-  svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, param1);
-
-  if (stack_valid(value_stack_offset)) {
-    stack_store_float(stack, value_stack_offset, value);
-  }
-  if (stack_valid(vector_stack_offset)) {
-    stack_store_float3(stack, vector_stack_offset, vector);
-  }
-  return offset;
-}
-
-CCL_NAMESPACE_END