Blender V5.3
math_dual.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7#include "util/math_base.h"
8#include "util/math_float3.h"
9#include "util/types_dual.h"
10#include "util/types_float3.h"
12
14
19
24
26{
27 return dual3();
28}
29
31{
32 return dual4();
33}
34
36{
37 return dual<Quaternion>();
38}
39
40template<class T> ccl_device_inline bool is_zero(const ccl_private dual<T> &a)
41{
42 return is_zero(a.val);
43}
44
45ccl_device_inline bool operator<(const ccl_private dual1 &a, const float b)
46{
47 return a.val < b;
48}
49
50/* Multiplication of dual by scalar. */
51template<class T1, class T2> ccl_device_inline dual<T1> operator*(const dual<T1> a, T2 b)
52{
53 return {a.val * b, a.dx * b, a.dy * b};
54}
55
56/* Multiplication of scalar by dual. */
57template<class T> ccl_device_inline dual<T> operator*(const T a, const ccl_private dual<T> &b)
58{
59 return {a * b.val, a * b.dx, a * b.dy};
60}
61
62/* Multiplication of duals.
63 * `(uv)' = uv' + u'v`. */
64template<class T1, class T2>
66{
67 return {u.val * v.val, u.val * v.dx + u.dx * v.val, u.val * v.dy + u.dy * v.val};
68}
69
70/* Division of dual by scalar. */
71template<class T> ccl_device_inline dual<T> operator/(const dual<T> a, T b)
72{
73 const T inv_b = 1.0f / b;
74 return {a.val * inv_b, a.dx * inv_b, a.dy * inv_b};
75}
76
77/* Division of dual by dual.
78 * `(u/v)' = (u' - v' * u/v) / v`. */
79template<class T1, class T2>
81{
82 const T2 inv_v = 1.0f / v.val;
83 /* NOTE: Numerically `u/v != u*inv_v`, for compatibility we compute `u/v`. */
84 const T1 u_v = u.val / v.val;
85 return {u_v, (u.dx - u_v * v.dx) * inv_v, (u.dy - u_v * v.dy) * inv_v};
86}
87
88template<class T1, class T2>
93
94/* Addition of duals. */
95template<class T> ccl_device_inline dual<T> operator+(const dual<T> a, const dual<T> b)
96{
97 return {a.val + b.val, a.dx + b.dx, a.dy + b.dy};
98}
99
100/* Addition of dual and scalar. */
101template<class T1, class T2> ccl_device_inline dual<T1> operator+(const dual<T1> a, T2 b)
102{
103 return {a.val + b, a.dx, a.dy};
104}
105
106/* Addition of scalar and dual. */
107template<class T1, class T2> ccl_device_inline dual<T2> operator+(const T1 a, const dual<T2> b)
108{
109 return {a + b.val, b.dx, b.dy};
110}
111
112/* Subtraction of dual by scalar. */
113template<class T1, class T2> ccl_device_inline dual<T1> operator-(const dual<T1> a, T2 b)
114{
115 return {a.val - b, a.dx, a.dy};
116}
117
118/* Subtraction of scalar by dual. */
119template<class T1, class T2> ccl_device_inline dual<T2> operator-(const T1 a, const dual<T2> b)
120{
121 return {a - b.val, -b.dx, -b.dy};
122}
123
124/* Subtraction of duals. */
125template<class T>
127{
128 return {a.val - b.val, a.dx - b.dx, a.dy - b.dy};
129}
130
131/* Negation. */
133{
134 return {-a.val, -a.dx, -a.dy};
135}
136
137/* `dfdx = dfdu * dudx`. */
138template<class T>
140 const ccl_private T &f,
141 const ccl_private T &dfdu)
142{
143 return {f, dfdu * u.dx, dfdu * u.dy};
144}
145
146/* `dfdx = dfdu * dudx + dfdv * dvdx`. */
147template<class T>
149 const ccl_private dual<T> &v,
150 const ccl_private T &f,
151 const ccl_private T &dfdu,
152 const ccl_private T &dfdv)
153{
154 return {f, dfdu * u.dx + dfdv * v.dx, dfdu * u.dy + dfdv * v.dy};
155}
156
157template<class MaskType>
158ccl_device_inline dual3 select(const MaskType mask, const dual3 a, const dual3 b)
159{
160#if defined(__KERNEL_METAL__)
161 const bool3 mask_ = bool3(mask);
162 return {metal::select(b.val, a.val, mask_),
163 metal::select(b.dx, a.dx, mask_),
164 metal::select(b.dy, a.dy, mask_)};
165#elif defined(__KERNEL_SSE__)
166# ifdef __KERNEL_SSE42__
167 const auto mask_ = _mm_castsi128_ps(mask.m128);
168 return {float3(_mm_blendv_ps(b.val.m128, a.val.m128, mask_)),
169 float3(_mm_blendv_ps(b.dx.m128, a.dx.m128, mask_)),
170 float3(_mm_blendv_ps(b.dy.m128, a.dy.m128, mask_))};
171# else
172 const auto mask_ = _mm_castsi128_ps(mask);
173 return {float3(_mm_or_ps(_mm_and_ps(mask_, a.val), _mm_andnot_ps(mask_, b.val))),
174 float3(_mm_or_ps(_mm_and_ps(mask_, a.dx), _mm_andnot_ps(mask_, b.dx))),
175 float3(_mm_or_ps(_mm_and_ps(mask_, a.dy), _mm_andnot_ps(mask_, b.dy)))};
176# endif
177#else
178 return make_float3(mask.x ? a.x() : b.x(), mask.y ? a.y() : b.y(), mask.z ? a.z() : b.z());
179#endif
180}
181
182/* Functions with zero derivatives. */
184{
185 return dual<T>(floor(a.val));
186}
187
189{
190 return dual<T>(ceil(a.val));
191}
192
194{
195 return dual<T>(compatible_sign(u.val));
196}
197
198/* f = u - round(u / v) * v, f' = u'. */
200{
201 return {safe_fmod(u.val, v.val), u.dx, u.dy};
202}
203
205{
206 return select(component_is_zero(b.val), make_zero<dual3>(), a - floor(a.val / b.val) * b);
207}
208
209template<class T> ccl_device_inline dual<T> safe_divide(const dual<T> f, const T g)
210{
211 return select(component_is_zero(g), make_zero<dual<T>>(), f / g);
212}
213
214template<class T>
219
220/* Adapted from GODOT-engine math_funcs.h. */
221ccl_device_inline dual3 wrap(const dual3 value, const dual3 max, const dual3 min)
222{
223 return safe_floored_fmod(value - min, max - min) + min;
224}
225
227{
228 return select(a.val < b.val, a, b);
229}
230
232{
233 return select(a.val > b.val, a, b);
234}
235
237{
238 return a.val > b.val ? a : b;
239}
240
242{
243 return select(a.val > zero_float3(), a, -a);
244}
245
246template<class T> ccl_device_inline dual1 average(const dual<T> a)
247{
248 return {average(a.val), average(a.dx), average(a.dy)};
249}
250
251template<class T> ccl_device_inline dual1 reduce_add(const dual<T> a)
252{
253 return {reduce_add(a.val), reduce_add(a.dx), reduce_add(a.dy)};
254}
255
256/* f(u) = sqrt(u), dfdu = 1 / (2 * sqrt(u)). */
258{
259 const float f = sqrtf(u.val);
260 return chain_rule(u, f, 0.5f / f);
261}
262
263template<class T> ccl_device_inline dual1 len(const ccl_private dual<T> &a)
264{
265 return sqrt(dot(a, a));
266}
267
268template<class T1, class T2> ccl_device_inline dual1 dot(const dual<T1> a, const T2 b)
269{
270 return reduce_add(a * b);
271}
272
274{
275 return dot(a, a);
276}
277
278template<class T>
280{
281 return len(a - b);
282}
283
285{
286 return {cross(a.val, b.val),
287 cross(a.val, b.dx) + cross(a.dx, b.val),
288 cross(a.val, b.dy) + cross(a.dy, b.val)};
289}
290
292{
293 return {cross(a.val, b), cross(a.dx, b), cross(a.dy, b)};
294}
295
297{
298 return -cross(b, a);
299}
300
301/* f(u) = 1 / sqrt(u), dfdu = -1 / (2 * u^(3/2)). */
303{
304 const float f = inversesqrtf(u.val);
305 return chain_rule(u, f, -0.5f * safe_divide(f, u.val));
306}
307
309{
310 return a * inversesqrt(len_squared(a));
311}
312
314{
315 const dual1 len_sq = len_squared(a);
316 return is_zero(len_sq) ? make_zero<dual<T>>() : a * inversesqrt(len_sq);
317}
318
319/* f(y, x) = atan2(y, x),
320 * dfdx = -y / (x^2 + y^2),
321 * dfdy = x / (x^2 + y^2) */
323{
324 const float inv_len = safe_divide(1.0f, sqr(x.val) + sqr(y.val));
325 const float dfdx = -y.val * inv_len;
326 const float dfdy = x.val * inv_len;
327 return chain_rule(x, y, atan2f(y.val, x.val), dfdx, dfdy);
328}
329
330/* f(u) = acos(u), dfdu = -1 / sqrt(1 - u^2). */
332{
333 return chain_rule(u, acosf(u.val), -inversesqrtf(1.0f - sqr(u.val)));
334}
335
337{
338 const float dfdu = (fabsf(u.val) >= 1.0f) ? 0.0f : -inversesqrtf(1.0f - sqr(u.val));
339 return chain_rule(u, safe_acosf(u.val), dfdu);
340}
341
342template<class T> ccl_device_inline dual3 reflect(const dual3 incident, const T unit_normal)
343{
344 return incident - unit_normal * make_float3(dot(incident, unit_normal)) * 2.0f;
345}
346
347ccl_device_inline dual3 refract(const dual3 incident, const dual3 normal, const dual1 eta)
348{
349 const dual1 NI = dot(incident, normal);
350 const dual1 k = 1.0f - eta * eta * (1.0f - NI * NI);
351 if (k.val < 0.0f) {
352 return dual3();
353 }
354 return incident * eta - normal * (eta * NI + sqrt(k));
355}
356
358 const dual3 incident,
359 const dual3 reference)
360{
361 return (dot(reference, incident) < 0.0f) ? vector : -vector;
362}
363
365{
366 const dual1 len_squared = dot(v_proj, v_proj);
367 return (len_squared.val != 0.0f) ? v_proj * (dot(v, v_proj) / len_squared) : dual3();
368}
369
371{
372 T sinx, cosx;
373 sincos(x.val, &sinx, &cosx);
374 return chain_rule(x, sinx, cosx);
375}
376
378{
379 T sinx, cosx;
380 sincos(x.val, &sinx, &cosx);
381 return chain_rule(x, cosx, -sinx);
382}
383
385{
386 const float3 tanx = tan(x.val);
387 const float3 secx = safe_divide(one_float3(), cos(x.val));
388 return chain_rule(x, tanx, sqr(secx));
389}
390
391/* f(u, v) = u^v, dfdu = v u^(v-1), dfdv = u^v ln(u). */
392template<class T>
394{
395 /* u^(v-1). */
396 const T u_v_minus_1 = safe_pow(u.val, v.val - 1.0f);
397 /* u^v = u * u^(v-1). */
398 /* NOTE: numerically `u^v != u*u^(v-1)`, but the current behavior matches OSL. */
399 const T f = u.val * u_v_minus_1;
400 return chain_rule(u, v, f, v.val * u_v_minus_1, f * safe_log(u.val));
401}
402
403/* Projections. */
405{
406 dual1 u, v;
407 const dual1 length = len(make_float2(co));
408 if (length.val > 0.0f) {
409 u = (1.0f - (atan2(co.x(), co.y()) / M_PI_F)) * 0.5f;
410 v = (co.z() + 1.0f) * 0.5f;
411 }
412 else {
413 u = v = make_zero<dual1>();
414 }
415 return make_float2(u, v);
416}
417
419{
420 const dual1 l = dot(co, co);
421 dual1 u, v;
422 if (l.val > 0.0f) {
423 if (UNLIKELY(co.val.x == 0.0f && co.val.y == 0.0f)) {
424 u = make_zero<dual1>(); /* Otherwise domain error. */
425 }
426 else {
427 u = (0.5f - atan2(co.x(), co.y()) * M_1_2PI_F);
428 }
429 v = 1.0f - safe_acos(co.z() * inversesqrt(l)) * M_1_PI_F;
430 }
431 else {
432 u = v = make_zero<dual1>();
433 }
434 return make_float2(u, v);
435}
436
#define UNLIKELY(x)
btScalar max
#define ccl_private
#define ccl_device_inline
#define M_1_PI_F
#define M_1_2PI_F
#define ccl_device_template_spec
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
#define acosf(x)
#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
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< T, D > faceforward(VecOp< T, D >, VecOp< T, D >, VecOp< T, D >) RET
constexpr T inversesqrt(T) RET
#define select(A, B, C)
#define floor
float distance(float, float) RET
#define ceil
#define sqrt
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float length(VecOp< float, D >) RET
#define acos
VecBase< bool, 3 > bool3
#define atan2
bool is_zero(float3x3 a)
float wrap(float a, float b, float c)
float safe_divide(float a, float b)
float safe_acos(float a)
float reduce_add(float2 a)
float average(float2 a)
VecT safe_normalize(VecT vector)
__forceinline LightTreeMeasure operator+(const LightTreeMeasure &a, const LightTreeMeasure &b)
ccl_device_inline Interval< T1 > operator/=(ccl_private Interval< T1 > &interval, const T2 f)
Definition math_base.h:938
ccl_device_inline float inversesqrtf(const float f)
Definition math_base.h:576
ccl_device_inline Extrema< T > operator*(const Extrema< T > a, const T b)
Definition math_base.h:967
ccl_device float safe_acosf(const float a)
Definition math_base.h:590
ccl_device_inline T make_zero()
Definition math_dual.h:20
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 dual1 len_squared(const ccl_private dual< T > &a)
Definition math_dual.h:273
ccl_device_inline dual< T > operator/(const dual< T > a, T b)
Definition math_dual.h:71
ccl_device_inline dual3 safe_floored_fmod(const dual3 a, const dual3 b)
Definition math_dual.h:204
ccl_device_inline dual2 map_to_tube(const dual3 co)
Definition math_dual.h:404
ccl_device_inline dual2 map_to_sphere(const dual3 co)
Definition math_dual.h:418
ccl_device_inline dual< T1 > operator-(const dual< T1 > a, T2 b)
Definition math_dual.h:113
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
Definition math_dual.h:241
ccl_device_inline dual< T > chain_rule(const ccl_private dual< T > &u, const ccl_private T &f, const ccl_private T &dfdu)
Definition math_dual.h:139
ccl_device_inline bool operator<(const ccl_private dual1 &a, const float b)
Definition math_dual.h:45
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_device_inline float2 mask(const MaskType mask, const float2 a)
ccl_device_inline void sincos(const float3 x, ccl_private float3 *sine, ccl_private float3 *cosine)
ccl_device_inline float3 one_float3()
Definition math_float3.h:26
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
ccl_device_inline auto component_is_zero(const float3 a)
#define T
#define T2
Definition md5.cpp:21
#define T1
Definition md5.cpp:20
vector project(vector v, vector v_proj)
Definition node_math.h:141
float safe_log(float a, float b)
Definition node_math.h:136
#define sqr
#define fabsf
#define sqrtf
#define make_float2
#define M_PI_F
#define atan2f
#define min(a, b)
Definition sort.cc:38
ccl_device_inline_method dual< float > x() const
Definition types_dual.h:62
ccl_device_inline_method dual< float > y() const
Definition types_dual.h:66
ccl_device_inline_method dual< float > z() const
Definition types_dual.h:70
dual()=default
T val
Definition types_dual.h:14
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
dual< float4 > dual4
Definition types_dual.h:107
dual< float3 > dual3
Definition types_dual.h:106
dual< float2 > dual2
Definition types_dual.h:105
dual< float > dual1
Definition types_dual.h:104