1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#pragma once
#include "DNA_node_types.h"
#include "BLI_math_base_safe.h"
#include "BLI_math_rotation.h"
#include "BLI_string_ref.hh"
namespace blender::nodes {
struct FloatMathOperationInfo {
StringRefNull title_case_name;
StringRefNull shader_name;
FloatMathOperationInfo() = delete;
FloatMathOperationInfo(StringRefNull title_case_name, StringRefNull shader_name)
: title_case_name(title_case_name), shader_name(shader_name)
{
}
};
const FloatMathOperationInfo *get_float_math_operation_info(const int operation);
const FloatMathOperationInfo *get_float_compare_operation_info(const int operation);
/**
* This calls the `callback` with two arguments:
* 1. The math function that takes a float as input and outputs a new float.
* 2. A #FloatMathOperationInfo struct reference.
* Returns true when the callback has been called, otherwise false.
*
* The math function that is passed to the callback is actually a lambda function that is different
* for every operation. Therefore, if the callback is templated on the math function, it will get
* instantiated for every operation separately. This has two benefits:
* - The compiler can optimize the callback for every operation separately.
* - A static variable declared in the callback will be generated for every operation separately.
*
* If separate instantiations are not desired, the callback can also take a function pointer with
* the following signature as input instead: float (*math_function)(float a).
*/
template<typename Callback>
inline bool try_dispatch_float_math_fl_to_fl(const int operation, Callback &&callback)
{
const FloatMathOperationInfo *info = get_float_math_operation_info(operation);
if (info == nullptr) {
return false;
}
/* This is just an utility function to keep the individual cases smaller. */
auto dispatch = [&](auto math_function) -> bool {
callback(math_function, *info);
return true;
};
switch (operation) {
case NODE_MATH_EXPONENT:
return dispatch([](float a) { return expf(a); });
case NODE_MATH_SQRT:
return dispatch([](float a) { return safe_sqrtf(a); });
case NODE_MATH_INV_SQRT:
return dispatch([](float a) { return safe_inverse_sqrtf(a); });
case NODE_MATH_ABSOLUTE:
return dispatch([](float a) { return fabs(a); });
case NODE_MATH_RADIANS:
return dispatch([](float a) { return (float)DEG2RAD(a); });
case NODE_MATH_DEGREES:
return dispatch([](float a) { return (float)RAD2DEG(a); });
case NODE_MATH_SIGN:
return dispatch([](float a) { return compatible_signf(a); });
case NODE_MATH_ROUND:
return dispatch([](float a) { return floorf(a + 0.5f); });
case NODE_MATH_FLOOR:
return dispatch([](float a) { return floorf(a); });
case NODE_MATH_CEIL:
return dispatch([](float a) { return ceilf(a); });
case NODE_MATH_FRACTION:
return dispatch([](float a) { return a - floorf(a); });
case NODE_MATH_TRUNC:
return dispatch([](float a) { return a >= 0.0f ? floorf(a) : ceilf(a); });
case NODE_MATH_SINE:
return dispatch([](float a) { return sinf(a); });
case NODE_MATH_COSINE:
return dispatch([](float a) { return cosf(a); });
case NODE_MATH_TANGENT:
return dispatch([](float a) { return tanf(a); });
case NODE_MATH_SINH:
return dispatch([](float a) { return sinhf(a); });
case NODE_MATH_COSH:
return dispatch([](float a) { return coshf(a); });
case NODE_MATH_TANH:
return dispatch([](float a) { return tanhf(a); });
case NODE_MATH_ARCSINE:
return dispatch([](float a) { return safe_asinf(a); });
case NODE_MATH_ARCCOSINE:
return dispatch([](float a) { return safe_acosf(a); });
case NODE_MATH_ARCTANGENT:
return dispatch([](float a) { return atanf(a); });
}
return false;
}
/**
* This is similar to try_dispatch_float_math_fl_to_fl, just with a different callback signature.
*/
template<typename Callback>
inline bool try_dispatch_float_math_fl_fl_to_fl(const int operation, Callback &&callback)
{
const FloatMathOperationInfo *info = get_float_math_operation_info(operation);
if (info == nullptr) {
return false;
}
/* This is just an utility function to keep the individual cases smaller. */
auto dispatch = [&](auto math_function) -> bool {
callback(math_function, *info);
return true;
};
switch (operation) {
case NODE_MATH_ADD:
return dispatch([](float a, float b) { return a + b; });
case NODE_MATH_SUBTRACT:
return dispatch([](float a, float b) { return a - b; });
case NODE_MATH_MULTIPLY:
return dispatch([](float a, float b) { return a * b; });
case NODE_MATH_DIVIDE:
return dispatch([](float a, float b) { return safe_divide(a, b); });
case NODE_MATH_POWER:
return dispatch([](float a, float b) { return safe_powf(a, b); });
case NODE_MATH_LOGARITHM:
return dispatch([](float a, float b) { return safe_logf(a, b); });
case NODE_MATH_MINIMUM:
return dispatch([](float a, float b) { return std::min(a, b); });
case NODE_MATH_MAXIMUM:
return dispatch([](float a, float b) { return std::max(a, b); });
case NODE_MATH_LESS_THAN:
return dispatch([](float a, float b) { return (float)(a < b); });
case NODE_MATH_GREATER_THAN:
return dispatch([](float a, float b) { return (float)(a > b); });
case NODE_MATH_MODULO:
return dispatch([](float a, float b) { return safe_modf(a, b); });
case NODE_MATH_SNAP:
return dispatch([](float a, float b) { return floorf(safe_divide(a, b)) * b; });
case NODE_MATH_ARCTAN2:
return dispatch([](float a, float b) { return atan2f(a, b); });
case NODE_MATH_PINGPONG:
return dispatch([](float a, float b) { return pingpongf(a, b); });
}
return false;
}
/**
* This is similar to try_dispatch_float_math_fl_to_fl, just with a different callback signature.
*/
template<typename Callback>
inline bool try_dispatch_float_math_fl_fl_fl_to_fl(const int operation, Callback &&callback)
{
const FloatMathOperationInfo *info = get_float_math_operation_info(operation);
if (info == nullptr) {
return false;
}
/* This is just an utility function to keep the individual cases smaller. */
auto dispatch = [&](auto math_function) -> bool {
callback(math_function, *info);
return true;
};
switch (operation) {
case NODE_MATH_MULTIPLY_ADD:
return dispatch([](float a, float b, float c) { return a * b + c; });
case NODE_MATH_COMPARE:
return dispatch([](float a, float b, float c) -> float {
return ((a == b) || (fabsf(a - b) <= fmaxf(c, FLT_EPSILON))) ? 1.0f : 0.0f;
});
case NODE_MATH_SMOOTH_MIN:
return dispatch([](float a, float b, float c) { return smoothminf(a, b, c); });
case NODE_MATH_SMOOTH_MAX:
return dispatch([](float a, float b, float c) { return -smoothminf(-a, -b, -c); });
case NODE_MATH_WRAP:
return dispatch([](float a, float b, float c) { return wrapf(a, b, c); });
}
return false;
}
/**
* This is similar to try_dispatch_float_math_fl_to_fl, just with a different callback signature.
*/
template<typename Callback>
inline bool try_dispatch_float_math_fl_fl_to_bool(const FloatCompareOperation operation,
Callback &&callback)
{
const FloatMathOperationInfo *info = get_float_compare_operation_info(operation);
if (info == nullptr) {
return false;
}
/* This is just an utility function to keep the individual cases smaller. */
auto dispatch = [&](auto math_function) -> bool {
callback(math_function, *info);
return true;
};
switch (operation) {
case NODE_FLOAT_COMPARE_LESS_THAN:
return dispatch([](float a, float b) { return a < b; });
case NODE_FLOAT_COMPARE_LESS_EQUAL:
return dispatch([](float a, float b) { return a <= b; });
case NODE_FLOAT_COMPARE_GREATER_THAN:
return dispatch([](float a, float b) { return a > b; });
case NODE_FLOAT_COMPARE_GREATER_EQUAL:
return dispatch([](float a, float b) { return a >= b; });
default:
return false;
}
return false;
}
} // namespace blender::nodes
|
