Blender  V3.3
map_range.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0
2  * Copyright 2011-2022 Blender Foundation */
3 
4 #pragma once
5 
7 
8 /* Map Range Node */
9 
10 ccl_device_inline float smootherstep(float edge0, float edge1, float x)
11 {
12  x = clamp(safe_divide((x - edge0), (edge1 - edge0)), 0.0f, 1.0f);
13  return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f);
14 }
15 
18  ccl_private float *stack,
19  uint value_stack_offset,
20  uint parameters_stack_offsets,
21  uint results_stack_offsets,
22  int offset)
23 {
24  uint from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset;
25  uint type_stack_offset, steps_stack_offset, result_stack_offset;
26  svm_unpack_node_uchar4(parameters_stack_offsets,
27  &from_min_stack_offset,
28  &from_max_stack_offset,
29  &to_min_stack_offset,
30  &to_max_stack_offset);
32  results_stack_offsets, &type_stack_offset, &steps_stack_offset, &result_stack_offset);
33 
34  uint4 defaults = read_node(kg, &offset);
35  uint4 defaults2 = read_node(kg, &offset);
36 
37  float value = stack_load_float(stack, value_stack_offset);
38  float from_min = stack_load_float_default(stack, from_min_stack_offset, defaults.x);
39  float from_max = stack_load_float_default(stack, from_max_stack_offset, defaults.y);
40  float to_min = stack_load_float_default(stack, to_min_stack_offset, defaults.z);
41  float to_max = stack_load_float_default(stack, to_max_stack_offset, defaults.w);
42  float steps = stack_load_float_default(stack, steps_stack_offset, defaults2.x);
43 
44  float result;
45 
46  if (from_max != from_min) {
47  float factor = value;
48  switch (type_stack_offset) {
49  default:
51  factor = (value - from_min) / (from_max - from_min);
52  break;
54  factor = (value - from_min) / (from_max - from_min);
55  factor = (steps > 0.0f) ? floorf(factor * (steps + 1.0f)) / steps : 0.0f;
56  break;
57  }
59  factor = (from_min > from_max) ? 1.0f - smoothstep(from_max, from_min, factor) :
60  smoothstep(from_min, from_max, factor);
61  break;
62  }
64  factor = (from_min > from_max) ? 1.0f - smootherstep(from_max, from_min, factor) :
65  smootherstep(from_min, from_max, factor);
66  break;
67  }
68  }
69  result = to_min + factor * (to_max - to_min);
70  }
71  else {
72  result = 0.0f;
73  }
74  stack_store_float(stack, result_stack_offset, result);
75  return offset;
76 }
77 
80  ccl_private float *stack,
81  uint value_stack_offset,
82  uint parameters_stack_offsets,
83  uint results_stack_offsets,
84  int offset)
85 {
86  uint from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset;
87  uint steps_stack_offset, clamp_stack_offset, range_type_stack_offset, result_stack_offset;
88  svm_unpack_node_uchar4(parameters_stack_offsets,
89  &from_min_stack_offset,
90  &from_max_stack_offset,
91  &to_min_stack_offset,
92  &to_max_stack_offset);
93  svm_unpack_node_uchar4(results_stack_offsets,
94  &steps_stack_offset,
95  &clamp_stack_offset,
96  &range_type_stack_offset,
97  &result_stack_offset);
98 
99  float3 value = stack_load_float3(stack, value_stack_offset);
100  float3 from_min = stack_load_float3(stack, from_min_stack_offset);
101  float3 from_max = stack_load_float3(stack, from_max_stack_offset);
102  float3 to_min = stack_load_float3(stack, to_min_stack_offset);
103  float3 to_max = stack_load_float3(stack, to_max_stack_offset);
104  float3 steps = stack_load_float3(stack, steps_stack_offset);
105 
106  int type = range_type_stack_offset;
108  0 :
109  clamp_stack_offset;
110  float3 result;
111  float3 factor = value;
112  switch (range_type_stack_offset) {
113  default:
115  factor = safe_divide((value - from_min), (from_max - from_min));
116  break;
117  case NODE_MAP_RANGE_STEPPED: {
118  factor = safe_divide((value - from_min), (from_max - from_min));
119  factor = make_float3((steps.x > 0.0f) ? floorf(factor.x * (steps.x + 1.0f)) / steps.x : 0.0f,
120  (steps.y > 0.0f) ? floorf(factor.y * (steps.y + 1.0f)) / steps.y : 0.0f,
121  (steps.z > 0.0f) ? floorf(factor.z * (steps.z + 1.0f)) / steps.z :
122  0.0f);
123  break;
124  }
126  factor = safe_divide((value - from_min), (from_max - from_min));
127  factor = clamp(factor, zero_float3(), one_float3());
128  factor = (make_float3(3.0f, 3.0f, 3.0f) - 2.0f * factor) * (factor * factor);
129  break;
130  }
132  factor = safe_divide((value - from_min), (from_max - from_min));
133  factor = clamp(factor, zero_float3(), one_float3());
134  factor = factor * factor * factor * (factor * (factor * 6.0f - 15.0f) + 10.0f);
135  break;
136  }
137  }
138  result = to_min + factor * (to_max - to_min);
139  if (use_clamp > 0) {
140  result.x = (to_min.x > to_max.x) ? clamp(result.x, to_max.x, to_min.x) :
141  clamp(result.x, to_min.x, to_max.x);
142  result.y = (to_min.y > to_max.y) ? clamp(result.y, to_max.y, to_min.y) :
143  clamp(result.y, to_min.y, to_max.y);
144  result.z = (to_min.z > to_max.z) ? clamp(result.z, to_max.z, to_min.z) :
145  clamp(result.z, to_min.z, to_max.z);
146  }
147 
148  stack_store_float3(stack, result_stack_offset, result);
149  return offset;
150 }
151 
unsigned int uint
Definition: BLI_sys_types.h:67
@ NODE_MAP_RANGE_STEPPED
@ NODE_MAP_RANGE_SMOOTHERSTEP
@ NODE_MAP_RANGE_SMOOTHSTEP
@ NODE_MAP_RANGE_LINEAR
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
#define ccl_private
Definition: cuda/compat.h:48
#define ccl_device_inline
Definition: cuda/compat.h:34
#define ccl_device_noinline
Definition: cuda/compat.h:40
#define CCL_NAMESPACE_END
Definition: cuda/compat.h:9
const KernelGlobalsCPU *ccl_restrict KernelGlobals
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
ccl_device_inline void stack_store_float3(ccl_private float *stack, uint a, float3 f)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 stack_load_float3(ccl_private float *stack, uint a)
ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset)
ccl_device_forceinline void svm_unpack_node_uchar3(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z)
ccl_device_inline float stack_load_float_default(ccl_private float *stack, uint a, uint value)
ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f)
ccl_device_inline float stack_load_float(ccl_private float *stack, uint a)
ccl_device_forceinline void svm_unpack_node_uchar4(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z, ccl_private uint *w)
ShaderData
Definition: kernel/types.h:925
ccl_device_noinline int svm_node_vector_map_range(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint value_stack_offset, uint parameters_stack_offsets, uint results_stack_offsets, int offset)
Definition: map_range.h:78
ccl_device_noinline int svm_node_map_range(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint value_stack_offset, uint parameters_stack_offsets, uint results_stack_offsets, int offset)
Definition: map_range.h:16
CCL_NAMESPACE_BEGIN ccl_device_inline float smootherstep(float edge0, float edge1, float x)
Definition: map_range.h:10
MINLINE float smoothstep(float edge0, float edge1, float x)
ccl_device_inline float3 one_float3()
Definition: math_float3.h:89
ccl_device_inline float3 zero_float3()
Definition: math_float3.h:80
#define floorf(x)
Definition: metal/compat.h:224
#define make_float3(x, y, z)
Definition: metal/compat.h:204
T clamp(const T &a, const T &min, const T &max)
T safe_divide(const T &a, const T &b)
static const int steps
Definition: sky_nishita.cpp:19
float z
float y
float x
uint x
Definition: types_uint4.h:15
uint y
Definition: types_uint4.h:15
uint z
Definition: types_uint4.h:15
uint w
Definition: types_uint4.h:15