Blender V5.3
math_util.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7#include "kernel/svm/types.h"
8#include "kernel/tables.h"
9
10#include "util/math.h"
11#include "util/types.h"
12
14
15template<class Float3Type, class FloatType>
17 ccl_private Float3Type *vector,
19 const Float3Type a,
20 const Float3Type b,
21 const Float3Type c,
22 const FloatType param1)
23{
24 switch (type) {
26 *vector = a + b;
27 break;
29 *vector = a - b;
30 break;
32 *vector = a * b;
33 break;
35 *vector = safe_divide(a, b);
36 break;
38 *vector = cross(a, b);
39 break;
41 *vector = project(a, b);
42 break;
45 break;
47 *vector = refract(a, safe_normalize(b), param1);
48 break;
50 *vector = faceforward(a, b, c);
51 break;
53 *vector = a * b + c;
54 break;
56 *value = dot(a, b);
57 break;
59 *value = distance(a, b);
60 break;
62 *value = len(a);
63 break;
65 *vector = a * param1;
66 break;
69 break;
71 *vector = floor(safe_divide(a, b)) * b;
72 break;
74 *vector = floor(a + 0.5f);
75 break;
77 *vector = floor(a);
78 break;
80 *vector = ceil(a);
81 break;
83 *vector = safe_fmod(a, b);
84 break;
86 *vector = wrap(a, b, c);
87 break;
89 *vector = a - floor(a);
90 break;
92 *vector = fabs(a);
93 break;
95 *vector = safe_pow(a, b);
96 break;
99 break;
101 *vector = min(a, b);
102 break;
104 *vector = max(a, b);
105 break;
107 *vector = sin(a);
108 break;
110 *vector = cos(a);
111 break;
113 *vector = tan(a);
114 break;
115 default:
116 *vector = Float3Type(zero_float3());
117 *value = FloatType(0.0f);
118 }
119}
120
121ccl_device float svm_math(NodeMathType type, const float a, float b, const float c)
122{
123 switch (type) {
124 case NODE_MATH_ADD:
125 return a + b;
127 return a - b;
129 return a * b;
130 case NODE_MATH_DIVIDE:
131 return safe_divide(a, b);
132 case NODE_MATH_POWER:
133 return safe_powf(a, b);
135 return safe_logf(a, b);
136 case NODE_MATH_SQRT:
137 return safe_sqrtf(a);
139 return inversesqrtf(a);
141 return fabsf(a);
143 return a * (M_PI_F / 180.0f);
145 return a * (180.0f / M_PI_F);
147 return fminf(a, b);
149 return fmaxf(a, b);
151 return a < b;
153 return a > b;
154 case NODE_MATH_ROUND:
155 return floorf(a + 0.5f);
156 case NODE_MATH_FLOOR:
157 return floorf(a);
158 case NODE_MATH_CEIL:
159 return ceilf(a);
161 return a - floorf(a);
162 case NODE_MATH_MODULO:
163 return safe_modulo(a, b);
165 return safe_floored_modulo(a, b);
166 case NODE_MATH_TRUNC:
167 return a >= 0.0f ? floorf(a) : ceilf(a);
168 case NODE_MATH_SNAP:
169 return floorf(safe_divide(a, b)) * b;
170 case NODE_MATH_WRAP:
171 return wrapf(a, b, c);
173 return pingpongf(a, b);
174 case NODE_MATH_SINE:
175 return sinf(a);
176 case NODE_MATH_COSINE:
177 return cosf(a);
179 return tanf(a);
180 case NODE_MATH_SINH:
181 return sinhf(a);
182 case NODE_MATH_COSH:
183 return coshf(a);
184 case NODE_MATH_TANH:
185 return tanhf(a);
187 return safe_asinf(a);
189 return safe_acosf(a);
191 return atanf(a);
193 return compatible_atan2(a, b);
194 case NODE_MATH_SIGN:
195 return compatible_signf(a);
197 return expf(a);
199 return ((a == b) || (fabsf(a - b) <= fmaxf(c, FLT_EPSILON))) ? 1.0f : 0.0f;
201 return a * b + c;
203 return smoothminf(a, b, c);
205 return -smoothminf(-a, -b, c);
206 default:
207 return 0.0f;
208 }
209}
210
212{
213 /* Calculate color in range 800..12000 using an approximation
214 * a/x+bx+c for R and G and ((at + b)t + c)t + d) for B.
215 *
216 * The result of this can be negative to support gamut wider than
217 * than rec.709, just needs to be clamped. */
218
219 if (t >= 12000.0f) {
220 return make_float3(0.8262954810464208f, 0.9945080501520986f, 1.566307710274283f);
221 }
222 if (t < 800.0f) {
223 /* Arbitrary lower limit where light is very dim, matching OSL. */
224 return make_float3(5.413294490189271f, -0.20319390035873933f, -0.0822535242887164f);
225 }
226
227 const int i = (t >= 6365.0f) ? 6 :
228 (t >= 3315.0f) ? 5 :
229 (t >= 1902.0f) ? 4 :
230 (t >= 1449.0f) ? 3 :
231 (t >= 1167.0f) ? 2 :
232 (t >= 965.0f) ? 1 :
233 0;
234
235 ccl_constant float *r = blackbody_table_r[i];
236 ccl_constant float *g = blackbody_table_g[i];
237 ccl_constant float *b = blackbody_table_b[i];
238
239 const float t_inv = 1.0f / t;
240 return make_float3(r[0] * t_inv + r[1] * t + r[2],
241 g[0] * t_inv + g[1] * t + g[2],
242 ((b[0] * t + b[1]) * t + b[2]) * t + b[3]);
243}
244
246{
247 if (gamma == 0.0f) {
248 return make_float3(1.0f, 1.0f, 1.0f);
249 }
250
251 if (color.x > 0.0f) {
252 color.x = powf(color.x, gamma);
253 }
254 if (color.y > 0.0f) {
255 color.y = powf(color.y, gamma);
256 }
257 if (color.z > 0.0f) {
258 color.z = powf(color.z, gamma);
259 }
260
261 return color;
262}
263
265{
266 float ii = (lambda_nm - 380.0f) * (1.0f / 5.0f); // scaled 0..80
267 const int i = float_to_int(ii);
268 float3 color;
269
270 if (i < 0 || i >= WAVELENGTH_RESOLUTION) {
271 color = make_float3(0.0f, 0.0f, 0.0f);
272 }
273 else {
274 ii -= i;
275 ccl_constant float *c = cie_color_match[i];
276 color = interp(make_float3(c[0], c[1], c[2]), make_float3(c[3], c[4], c[5]), ii);
277 }
278
279 return color;
280}
281
btScalar max
#define ccl_constant
#define ccl_private
#define ccl_device_inline
#define expf(x)
#define powf(x, y)
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
#define tanhf(x)
#define sinhf(x)
#define coshf(x)
#define FLT_EPSILON
#define tan
#define sin
VecBase< T, D > refract(VecOp< T, D >, VecOp< T, D >, float) RET
VecBase< T, D > reflect(VecOp< T, D >, VecOp< T, D >) RET
#define cos
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< T, D > faceforward(VecOp< T, D >, VecOp< T, D >, VecOp< T, D >) RET
#define floor
float distance(float, float) RET
#define ceil
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float wrap(float a, float b, float c)
float safe_divide(float a, float b)
VecT safe_normalize(VecT vector)
NodeMathType
@ NODE_MATH_SINH
@ NODE_MATH_SMOOTH_MIN
@ NODE_MATH_TRUNC
@ NODE_MATH_COSH
@ NODE_MATH_SIGN
@ NODE_MATH_DEGREES
@ NODE_MATH_MODULO
@ NODE_MATH_ABSOLUTE
@ NODE_MATH_DIVIDE
@ NODE_MATH_SINE
@ NODE_MATH_FLOORED_MODULO
@ NODE_MATH_ARCTAN2
@ NODE_MATH_ARCCOSINE
@ NODE_MATH_MULTIPLY_ADD
@ NODE_MATH_POWER
@ NODE_MATH_WRAP
@ NODE_MATH_ARCTANGENT
@ NODE_MATH_MINIMUM
@ NODE_MATH_SQRT
@ NODE_MATH_CEIL
@ NODE_MATH_TANH
@ NODE_MATH_GREATER_THAN
@ NODE_MATH_ADD
@ NODE_MATH_FRACTION
@ NODE_MATH_EXPONENT
@ NODE_MATH_LESS_THAN
@ NODE_MATH_ARCSINE
@ NODE_MATH_MAXIMUM
@ NODE_MATH_LOGARITHM
@ NODE_MATH_COMPARE
@ NODE_MATH_INV_SQRT
@ NODE_MATH_MULTIPLY
@ NODE_MATH_PINGPONG
@ NODE_MATH_ROUND
@ NODE_MATH_FLOOR
@ NODE_MATH_SUBTRACT
@ NODE_MATH_COSINE
@ NODE_MATH_SNAP
@ NODE_MATH_TANGENT
@ NODE_MATH_SMOOTH_MAX
@ NODE_MATH_RADIANS
NodeVectorMathType
@ NODE_VECTOR_MATH_NORMALIZE
@ NODE_VECTOR_MATH_LENGTH
@ NODE_VECTOR_MATH_SIGN
@ NODE_VECTOR_MATH_CROSS_PRODUCT
@ NODE_VECTOR_MATH_CEIL
@ NODE_VECTOR_MATH_MODULO
@ NODE_VECTOR_MATH_ADD
@ NODE_VECTOR_MATH_COSINE
@ NODE_VECTOR_MATH_REFLECT
@ NODE_VECTOR_MATH_WRAP
@ NODE_VECTOR_MATH_REFRACT
@ NODE_VECTOR_MATH_POWER
@ NODE_VECTOR_MATH_DOT_PRODUCT
@ NODE_VECTOR_MATH_ABSOLUTE
@ NODE_VECTOR_MATH_DIVIDE
@ NODE_VECTOR_MATH_TANGENT
@ NODE_VECTOR_MATH_DISTANCE
@ NODE_VECTOR_MATH_FLOOR
@ NODE_VECTOR_MATH_SNAP
@ NODE_VECTOR_MATH_SINE
@ NODE_VECTOR_MATH_FRACTION
@ NODE_VECTOR_MATH_PROJECT
@ NODE_VECTOR_MATH_MULTIPLY
@ NODE_VECTOR_MATH_ROUND
@ NODE_VECTOR_MATH_SCALE
@ NODE_VECTOR_MATH_MAXIMUM
@ NODE_VECTOR_MATH_FACEFORWARD
@ NODE_VECTOR_MATH_SUBTRACT
@ NODE_VECTOR_MATH_MULTIPLY_ADD
@ NODE_VECTOR_MATH_MINIMUM
ccl_inline_constant float blackbody_table_r[][3]
ccl_inline_constant float cie_color_match[][3]
ccl_inline_constant float blackbody_table_g[][3]
#define WAVELENGTH_RESOLUTION
ccl_inline_constant float blackbody_table_b[][4]
ccl_device float safe_asinf(const float a)
Definition math_base.h:585
ccl_device float safe_powf(const float a, const float b)
Definition math_base.h:618
ccl_device_inline float inversesqrtf(const float f)
Definition math_base.h:576
ccl_device_inline float compatible_atan2(const float y, const float x)
Definition math_base.h:518
ccl_device_inline float safe_sqrtf(const float f)
Definition math_base.h:571
ccl_device float safe_acosf(const float a)
Definition math_base.h:590
ccl_device_inline float compatible_signf(const float f)
Definition math_base.h:524
ccl_device_inline float smoothminf(const float a, const float b, float k)
Definition math_base.h:493
ccl_device_inline int float_to_int(const float f)
Definition math_base.h:454
ccl_device_inline float interp(const float a, const float b, const float t)
Definition math_base.h:549
ccl_device_inline float wrapf(const float value, const float max, const float min)
Definition math_base.h:482
ccl_device float safe_logf(const float a, const float b)
Definition math_base.h:632
ccl_device_inline float pingpongf(const float a, const float b)
Definition math_base.h:488
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
ccl_device_inline dual< T > safe_pow(const ccl_private dual< T > &u, const ccl_private dual< T > &v)
Definition math_dual.h:393
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
Definition math_dual.h:241
ccl_device_inline dual< T > compatible_sign(const ccl_private dual< T > &u)
Definition math_dual.h:193
ccl_device_inline dual3 safe_fmod(const dual3 u, const dual3 v)
Definition math_dual.h:199
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
ccl_device float svm_math(NodeMathType type, const float a, float b, const float c)
Definition math_util.h:121
ccl_device float3 svm_math_wavelength_color_xyz(const float lambda_nm)
Definition math_util.h:264
ccl_device float3 svm_math_blackbody_color_rec709(const float t)
Definition math_util.h:211
ccl_device_inline float3 svm_math_gamma_color(float3 color, const float gamma)
Definition math_util.h:245
CCL_NAMESPACE_BEGIN ccl_device void svm_vector_math(ccl_private FloatType *value, ccl_private Float3Type *vector, NodeVectorMathType type, const Float3Type a, const Float3Type b, const Float3Type c, const FloatType param1)
Definition math_util.h:16
float safe_floored_modulo(float a, float b)
Definition node_math.h:27
vector project(vector v, vector v_proj)
Definition node_math.h:141
float safe_modulo(float a, float b)
Definition node_math.h:22
#define floorf
#define fabsf
#define ccl_device
#define atanf
#define fmaxf
#define sinf
#define tanf
#define fminf
#define M_PI_F
#define cosf
#define ceilf
#define min(a, b)
Definition sort.cc:38
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136