Blender V5.3
node_texture_math.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_listbase.hh"
11#include "node_texture_util.hh"
12#include "node_util.hh"
13
14namespace blender {
15
16/* **************** SCALAR MATH ******************** */
18 {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -100.0f, 100.0f, PROP_NONE},
19 {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -100.0f, 100.0f, PROP_NONE},
20 {SOCK_FLOAT, N_("Value"), 0.0f, 0.5f, 0.5f, 1.0f, -100.0f, 100.0f, PROP_NONE},
21 {-1, ""},
22};
23
25 {SOCK_FLOAT, N_("Value")},
26 {-1, ""},
27};
28
29static void valuefn(float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
30{
31 float in0 = tex_input_value(in[0], p, thread);
32 float in1 = tex_input_value(in[1], p, thread);
33
34 switch (node->custom1) {
35
36 case NODE_MATH_ADD:
37 *out = in0 + in1;
38 break;
40 *out = in0 - in1;
41 break;
43 *out = in0 * in1;
44 break;
45 case NODE_MATH_DIVIDE: {
46 if (in1 == 0) {
47 /* We don't want to divide by zero. */
48 *out = 0.0;
49 }
50 else {
51 *out = in0 / in1;
52 }
53 break;
54 }
55 case NODE_MATH_SINE: {
56 *out = sinf(in0);
57 break;
58 }
59 case NODE_MATH_COSINE: {
60 *out = cosf(in0);
61 break;
62 }
63 case NODE_MATH_TANGENT: {
64 *out = tanf(in0);
65 break;
66 }
67 case NODE_MATH_SINH: {
68 *out = sinhf(in0);
69 break;
70 }
71 case NODE_MATH_COSH: {
72 *out = coshf(in0);
73 break;
74 }
75 case NODE_MATH_TANH: {
76 *out = tanhf(in0);
77 break;
78 }
79 case NODE_MATH_ARCSINE: {
80 /* Can't do the impossible... */
81 if (in0 <= 1 && in0 >= -1) {
82 *out = asinf(in0);
83 }
84 else {
85 *out = 0.0;
86 }
87 break;
88 }
90 /* Can't do the impossible... */
91 if (in0 <= 1 && in0 >= -1) {
92 *out = acosf(in0);
93 }
94 else {
95 *out = 0.0;
96 }
97 break;
98 }
100 *out = atan(in0);
101 break;
102 }
103 case NODE_MATH_POWER: {
104 /* Only raise negative numbers by full integers */
105 if (in0 >= 0) {
106 out[0] = pow(in0, in1);
107 }
108 else {
109 float y_mod_1 = fmod(in1, 1);
110 if (y_mod_1 > 0.999f || y_mod_1 < 0.001f) {
111 *out = pow(in0, floor(in1 + 0.5f));
112 }
113 else {
114 *out = 0.0;
115 }
116 }
117 break;
118 }
119 case NODE_MATH_LOGARITHM: {
120 /* Don't want any imaginary numbers... */
121 if (in0 > 0 && in1 > 0) {
122 *out = log(in0) / log(in1);
123 }
124 else {
125 *out = 0.0;
126 }
127 break;
128 }
129 case NODE_MATH_MINIMUM: {
130 if (in0 < in1) {
131 *out = in0;
132 }
133 else {
134 *out = in1;
135 }
136 break;
137 }
138 case NODE_MATH_MAXIMUM: {
139 if (in0 > in1) {
140 *out = in0;
141 }
142 else {
143 *out = in1;
144 }
145 break;
146 }
147 case NODE_MATH_ROUND: {
148 *out = (in0 < 0) ? int(in0 - 0.5f) : int(in0 + 0.5f);
149 break;
150 }
151
152 case NODE_MATH_LESS_THAN: {
153 if (in0 < in1) {
154 *out = 1.0f;
155 }
156 else {
157 *out = 0.0f;
158 }
159 break;
160 }
161
163 if (in0 > in1) {
164 *out = 1.0f;
165 }
166 else {
167 *out = 0.0f;
168 }
169 break;
170 }
171
172 case NODE_MATH_MODULO: {
173 if (in1 == 0.0f) {
174 *out = 0.0f;
175 }
176 else {
177 *out = fmod(in0, in1);
178 }
179 break;
180 }
181
183 if (in1 == 0.0f) {
184 *out = 0.0f;
185 }
186 else {
187 *out = in0 - floorf(in0 / in1) * in1;
188 }
189 break;
190 }
191
192 case NODE_MATH_ABSOLUTE: {
193 *out = fabsf(in0);
194 break;
195 }
196
197 case NODE_MATH_RADIANS: {
198 *out = DEG2RADF(in0);
199 break;
200 }
201
202 case NODE_MATH_DEGREES: {
203 *out = RAD2DEGF(in0);
204 break;
205 }
206
207 case NODE_MATH_ARCTAN2: {
208 *out = atan2(in0, in1);
209 break;
210 }
211
212 case NODE_MATH_SIGN: {
213 *out = compatible_signf(in0);
214 break;
215 }
216
217 case NODE_MATH_EXPONENT: {
218 *out = expf(in0);
219 break;
220 }
221
222 case NODE_MATH_FLOOR: {
223 *out = floorf(in0);
224 break;
225 }
226
227 case NODE_MATH_CEIL: {
228 *out = ceilf(in0);
229 break;
230 }
231
232 case NODE_MATH_FRACTION: {
233 *out = in0 - floorf(in0);
234 break;
235 }
236
237 case NODE_MATH_SQRT: {
238 if (in0 > 0.0f) {
239 *out = sqrtf(in0);
240 }
241 else {
242 *out = 0.0f;
243 }
244 break;
245 }
246
247 case NODE_MATH_INV_SQRT: {
248 if (in0 > 0.0f) {
249 *out = 1.0f / sqrtf(in0);
250 }
251 else {
252 *out = 0.0f;
253 }
254 break;
255 }
256
257 case NODE_MATH_TRUNC: {
258 if (in0 > 0.0f) {
259 *out = floorf(in0);
260 }
261 else {
262 *out = ceilf(in0);
263 }
264 break;
265 }
266
267 case NODE_MATH_SNAP: {
268 if (in1 == 0) {
269 *out = 0.0;
270 }
271 else {
272 *out = floorf(in0 / in1) * in1;
273 }
274 break;
275 }
276
277 case NODE_MATH_WRAP: {
278 float in2 = tex_input_value(in[2], p, thread);
279 *out = wrapf(in0, in1, in2);
280 break;
281 }
282
283 case NODE_MATH_PINGPONG: {
284 *out = pingpongf(in0, in1);
285 break;
286 }
287
288 case NODE_MATH_COMPARE: {
289 float in2 = tex_input_value(in[2], p, thread);
290 *out = (fabsf(in0 - in1) <= std::max(in2, 1e-5f)) ? 1.0f : 0.0f;
291 break;
292 }
293
295 float in2 = tex_input_value(in[2], p, thread);
296 *out = in0 * in1 + in2;
297 break;
298 }
299
301 float in2 = tex_input_value(in[2], p, thread);
302 *out = smoothminf(in0, in1, in2);
303 break;
304 }
305
307 float in2 = tex_input_value(in[2], p, thread);
308 *out = -smoothminf(-in0, -in1, in2);
309 break;
310 }
311
312 default: {
313 BLI_assert(0);
314 break;
315 }
316 }
317
318 if (node->custom2 & SHD_MATH_CLAMP) {
319 CLAMP(*out, 0.0f, 1.0f);
320 }
321}
322
323static void node_update(bNodeTree *ntree, bNode *node)
324{
325 node_math_update(ntree, node);
326
327 bNodeSocket *sock1 = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 0));
328 bNodeSocket *sock2 = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 1));
329 bNodeSocket *sock3 = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, 2));
330
334
335 switch (node->custom1) {
336 case NODE_MATH_WRAP:
337 node_sock_label(sock2, "Max");
338 node_sock_label(sock3, "Min");
339 break;
341 node_sock_label(sock2, "Multiplier");
342 node_sock_label(sock3, "Addend");
343 break;
346 node_sock_label(sock2, "Threshold");
347 break;
349 node_sock_label(sock2, "Scale");
350 break;
351 case NODE_MATH_SNAP:
352 node_sock_label(sock2, "Increment");
353 break;
354 case NODE_MATH_POWER:
355 node_sock_label(sock1, "Base");
356 node_sock_label(sock2, "Exponent");
357 break;
359 node_sock_label(sock2, "Base");
360 break;
362 node_sock_label(sock1, "Radians");
363 break;
365 node_sock_label(sock1, "Degrees");
366 break;
368 node_sock_label(sock3, "Epsilon");
369 break;
372 node_sock_label(sock3, "Distance");
373 break;
374 }
375}
376
377static void exec(void *data,
378 int /*thread*/,
379 bNode *node,
380 bNodeExecData *execdata,
381 bNodeStack **in,
382 bNodeStack **out)
383{
384 tex_output(node, execdata, in, out[0], &valuefn, static_cast<TexCallData *>(data));
385}
386
388{
389 static bke::bNodeType ntype;
390
391 tex_node_type_base(&ntype, "TextureNodeMath"_ustr, TEX_NODE_MATH);
392 ntype.ui_name = "Math";
393 ntype.enum_name_legacy = "MATH";
397 ntype.exec_fn = exec;
398 ntype.updatefunc = node_update;
399
401}
402
403} // namespace blender
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define TEX_NODE_MATH
#define DEG2RADF(_deg)
#define RAD2DEGF(_rad)
#define CLAMP(a, b, c)
#define expf(x)
#define asinf(x)
#define acosf(x)
#define tanhf(x)
#define sinhf(x)
#define coshf(x)
#define atan
#define log
#define pow
#define floor
#define atan2
ccl_device_inline float2 fmod(const float2 a, const float b)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void node_type_socket_templates(bNodeType *ntype, bNodeSocketTemplate *inputs, bNodeSocketTemplate *outputs)
Definition node.cc:6134
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void node_math_label(const bNodeTree *, const bNode *node, char *label, int label_maxncpy)
Definition node_util.cc:158
MINLINE float wrapf(float value, float max, float min)
static void exec(void *data, int, bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out)
static void node_update(bNodeTree *ntree, bNode *node)
void register_node_type_tex_math()
void node_math_update(bNodeTree *ntree, bNode *node)
Definition node_util.cc:88
@ NODE_MATH_SMOOTH_MAX
@ NODE_MATH_LESS_THAN
@ NODE_MATH_GREATER_THAN
@ NODE_MATH_LOGARITHM
@ NODE_MATH_SMOOTH_MIN
@ NODE_MATH_FLOORED_MODULO
@ NODE_MATH_ARCCOSINE
@ NODE_MATH_ARCTANGENT
@ NODE_MATH_MULTIPLY_ADD
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void node_sock_label(bNodeSocket *sock, const char *name)
Definition node_util.cc:76
void node_sock_label_clear(bNodeSocket *sock)
Definition node_util.cc:81
BMesh const char void * data
void tex_output(bNode *node, bNodeExecData *, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *cdata)
MINLINE float pingpongf(float value, float scale)
static bke::bNodeSocketTemplate inputs[]
void tex_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
MINLINE float compatible_signf(float f)
MINLINE float smoothminf(float a, float b, float c)
float tex_input_value(bNodeStack *in, TexParams *params, short thread)
static void valuefn(float *out, TexParams *p, bNode *, bNodeStack **in, short thread)
static bke::bNodeSocketTemplate outputs[]
#define floorf
#define fabsf
#define sqrtf
#define sinf
#define tanf
#define cosf
#define ceilf
Compact definition of a node socket.
Definition BKE_node.hh:102
Defines a node type.
Definition BKE_node.hh:265
NodeExecFunction exec_fn
Definition BKE_node.hh:371
void(*) updatefunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:312
void(*) labelfunc(const bNodeTree *ntree, const bNode *node, char *label, int label_maxncpy)
Definition BKE_node.hh:301
const char * enum_name_legacy
Definition BKE_node.hh:274
#define N_(msgid)