Blender V5.3
rna_nodetree.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <climits>
10#include <cstdlib>
11#include <cstring>
12#include <type_traits>
13
16#include "BLI_string.hh"
17
18#include "BLT_translation.hh"
19
20#include "DNA_node_types.h"
21#include "DNA_object_types.h"
22#include "DNA_texture_types.h"
23
24#include "BKE_animsys.hh"
25#include "BKE_attribute.hh"
26#include "BKE_context.hh"
27#include "BKE_geometry_set.hh"
28#include "BKE_global.hh"
29#include "BKE_node.hh"
31#include "BKE_node_runtime.hh"
32
33#include "RNA_define.hh"
34#include "RNA_enum_types.hh"
35#include "RNA_path.hh"
36
37#include "NOD_common.hh"
38
39#include "rna_internal.hh"
40#include "rna_internal_types.hh"
41
43
44#include "UI_interface_c.hh"
45
46#include "WM_types.hh"
47
48namespace blender {
49
51 {SOCK_OUT, "OUT", 0, "Output", ""},
52 {0, nullptr, 0, nullptr, nullptr}};
53
55 {SOCK_FLOAT, "FLOAT", ICON_NODE_SOCKET_FLOAT, "Float", ""},
56 {SOCK_INT, "INT", ICON_NODE_SOCKET_INT, "Integer", ""},
57 {SOCK_BOOLEAN, "BOOLEAN", ICON_NODE_SOCKET_BOOLEAN, "Boolean", ""},
58 {SOCK_VECTOR, "VECTOR", ICON_NODE_SOCKET_VECTOR, "Vector", ""},
59 {SOCK_RGBA, "RGBA", ICON_NODE_SOCKET_RGBA, "Color", ""},
60 {SOCK_ROTATION, "ROTATION", ICON_NODE_SOCKET_ROTATION, "Rotation", ""},
61 {SOCK_MATRIX, "MATRIX", ICON_NODE_SOCKET_MATRIX, "Matrix", ""},
62 {SOCK_STRING, "STRING", ICON_NODE_SOCKET_STRING, "String", ""},
63 {SOCK_MENU, "MENU", ICON_NODE_SOCKET_MENU, "Menu", ""},
64 {SOCK_SHADER, "SHADER", ICON_NODE_SOCKET_SHADER, "Shader", ""},
65 {SOCK_OBJECT, "OBJECT", ICON_NODE_SOCKET_OBJECT, "Object", ""},
66 {SOCK_IMAGE, "IMAGE", ICON_NODE_SOCKET_IMAGE, "Image", ""},
67 {SOCK_GEOMETRY, "GEOMETRY", ICON_NODE_SOCKET_GEOMETRY, "Geometry", ""},
68 {SOCK_COLLECTION, "COLLECTION", ICON_NODE_SOCKET_COLLECTION, "Collection", ""},
69 {SOCK_TEXTURE, "TEXTURE", ICON_NODE_SOCKET_TEXTURE, "Texture", ""},
70 {SOCK_MATERIAL, "MATERIAL", ICON_NODE_SOCKET_MATERIAL, "Material", ""},
71 {SOCK_BUNDLE, "BUNDLE", ICON_NODE_SOCKET_BUNDLE, "Bundle", ""},
72 {SOCK_CLOSURE, "CLOSURE", ICON_NODE_SOCKET_CLOSURE, "Closure", ""},
73 {SOCK_FONT, "FONT", ICON_NODE_SOCKET_FONT, "Font", ""},
74 {SOCK_SCENE, "SCENE", ICON_NODE_SOCKET_SCENE, "Scene", ""},
75 {SOCK_TEXT_ID, "TEXT", ICON_NODE_SOCKET_TEXT, "Text", ""},
76 {SOCK_MASK, "MASK", ICON_NODE_SOCKET_MASK, "Mask", ""},
77 {SOCK_SOUND, "SOUND", ICON_NODE_SOCKET_SOUND, "Sound", ""},
78 {SOCK_INT_VECTOR, "INT_VECTOR", ICON_NODE_SOCKET_INT_VECTOR, "Integer Vector", ""},
79 {0, nullptr, 0, nullptr, nullptr},
80};
81
84 "NONE",
85 0,
86 "None",
87 "Default color tag for new nodes and node groups"},
88 {int(bke::NodeColorTag::Attribute), "ATTRIBUTE", 0, "Attribute", ""},
89 {int(bke::NodeColorTag::Color), "COLOR", 0, "Color", ""},
90 {int(bke::NodeColorTag::Converter), "CONVERTER", 0, "Converter", ""},
91 {int(bke::NodeColorTag::Distort), "DISTORT", 0, "Distort", ""},
92 {int(bke::NodeColorTag::Filter), "FILTER", 0, "Filter", ""},
93 {int(bke::NodeColorTag::Geometry), "GEOMETRY", 0, "Geometry", ""},
94 {int(bke::NodeColorTag::Input), "INPUT", 0, "Input", ""},
95 {int(bke::NodeColorTag::Matte), "MATTE", 0, "Matte", ""},
96 {int(bke::NodeColorTag::Output), "OUTPUT", 0, "Output", ""},
97 {int(bke::NodeColorTag::Script), "SCRIPT", 0, "Script", ""},
98 {int(bke::NodeColorTag::Shader), "SHADER", 0, "Shader", ""},
99 {int(bke::NodeColorTag::Texture), "TEXTURE", 0, "Texture", ""},
100 {int(bke::NodeColorTag::Vector), "VECTOR", 0, "Vector", ""},
101 {int(bke::NodeColorTag::Pattern), "PATTERN", 0, "Pattern", ""},
102 {int(bke::NodeColorTag::Interface), "INTERFACE", 0, "Interface", ""},
103 {int(bke::NodeColorTag::Group), "GROUP", 0, "Group", ""},
104 {0, nullptr, 0, nullptr, nullptr},
105};
106
108 {NODE_MAPPING_TYPE_POINT, "POINT", 0, "Point", "Transform a point"},
110 "TEXTURE",
111 0,
112 "Texture",
113 "Transform a texture by inverse mapping the texture coordinate"},
115 "VECTOR",
116 0,
117 "Vector",
118 "Transform a direction vector (Location is ignored)"},
120 "NORMAL",
121 0,
122 "Normal",
123 "Transform a unit normal vector (Location is ignored)"},
124 {0, nullptr, 0, nullptr, nullptr},
125};
126
129 "AXIS_ANGLE",
130 0,
131 "Axis Angle",
132 "Rotate a point using axis angle"},
133 {NODE_VECTOR_ROTATE_TYPE_AXIS_X, "X_AXIS", 0, "X Axis", "Rotate a point using X axis"},
134 {NODE_VECTOR_ROTATE_TYPE_AXIS_Y, "Y_AXIS", 0, "Y Axis", "Rotate a point using Y axis"},
135 {NODE_VECTOR_ROTATE_TYPE_AXIS_Z, "Z_AXIS", 0, "Z Axis", "Rotate a point using Z axis"},
136 {NODE_VECTOR_ROTATE_TYPE_EULER_XYZ, "EULER_XYZ", 0, "Euler", "Rotate a point using XYZ order"},
137 {0, nullptr, 0, nullptr, nullptr},
138};
139
142 {NODE_MATH_ADD, "ADD", 0, "Add", "A + B"},
143 {NODE_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", "A - B"},
144 {NODE_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", "A * B"},
145 {NODE_MATH_DIVIDE, "DIVIDE", 0, "Divide", "A / B"},
146 {NODE_MATH_MULTIPLY_ADD, "MULTIPLY_ADD", 0, "Multiply Add", "A * B + C"},
148 {NODE_MATH_POWER, "POWER", 0, "Power", "A power B"},
149 {NODE_MATH_LOGARITHM, "LOGARITHM", 0, "Logarithm", "Logarithm A base B"},
150 {NODE_MATH_SQRT, "SQRT", 0, "Square Root", "Square root of A"},
151 {NODE_MATH_INV_SQRT, "INVERSE_SQRT", 0, "Inverse Square Root", "1 / Square root of A"},
152 {NODE_MATH_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Magnitude of A"},
153 {NODE_MATH_EXPONENT, "EXPONENT", 0, "Exponent", "exp(A)"},
155 {NODE_MATH_MINIMUM, "MINIMUM", 0, "Minimum", "The minimum from A and B"},
156 {NODE_MATH_MAXIMUM, "MAXIMUM", 0, "Maximum", "The maximum from A and B"},
157 {NODE_MATH_LESS_THAN, "LESS_THAN", 0, "Less Than", "1 if A < B else 0"},
158 {NODE_MATH_GREATER_THAN, "GREATER_THAN", 0, "Greater Than", "1 if A > B else 0"},
159 {NODE_MATH_SIGN, "SIGN", 0, "Sign", "Returns the sign of A"},
160 {NODE_MATH_COMPARE, "COMPARE", 0, "Compare", "1 if (A == B) within tolerance C else 0"},
162 "SMOOTH_MIN",
163 0,
164 "Smooth Minimum",
165 "The minimum from A and B with smoothing C"},
167 "SMOOTH_MAX",
168 0,
169 "Smooth Maximum",
170 "The maximum from A and B with smoothing C"},
173 "ROUND",
174 0,
175 "Round",
176 "Round A to the nearest integer. Round upward if the fraction part is 0.5"},
177 {NODE_MATH_FLOOR, "FLOOR", 0, "Floor", "The largest integer smaller than or equal A"},
178 {NODE_MATH_CEIL, "CEIL", 0, "Ceil", "The smallest integer greater than or equal A"},
179 {NODE_MATH_TRUNC, "TRUNC", 0, "Truncate", "The integer part of A, removing fractional digits"},
181 {NODE_MATH_FRACTION, "FRACT", 0, "Fraction", "The fraction part of A"},
183 "MODULO",
184 0,
185 "Truncated Modulo",
186 "The remainder of truncated division using fmod(A,B)"},
188 "FLOORED_MODULO",
189 0,
190 "Floored Modulo",
191 "The remainder of floored division"},
192 {NODE_MATH_WRAP, "WRAP", 0, "Wrap", "Wrap value to range, wrap(A,B)"},
193 {NODE_MATH_SNAP, "SNAP", 0, "Snap", "Snap to increment, snap(A,B)"},
195 "PINGPONG",
196 0,
197 "Ping-Pong",
198 "Wraps a value and reverses every other cycle (A,B)"},
199 RNA_ENUM_ITEM_HEADING(CTX_N_(BLT_I18NCONTEXT_ID_NODETREE, "Trigonometric"), nullptr),
200 {NODE_MATH_SINE, "SINE", 0, "Sine", "sin(A)"},
201 {NODE_MATH_COSINE, "COSINE", 0, "Cosine", "cos(A)"},
202 {NODE_MATH_TANGENT, "TANGENT", 0, "Tangent", "tan(A)"},
204 {NODE_MATH_ARCSINE, "ARCSINE", 0, "Arcsine", "arcsin(A)"},
205 {NODE_MATH_ARCCOSINE, "ARCCOSINE", 0, "Arccosine", "arccos(A)"},
206 {NODE_MATH_ARCTANGENT, "ARCTANGENT", 0, "Arctangent", "arctan(A)"},
207 {NODE_MATH_ARCTAN2, "ARCTAN2", 0, "Arctan2", "The signed angle arctan(A / B)"},
209 {NODE_MATH_SINH, "SINH", 0, "Hyperbolic Sine", "sinh(A)"},
210 {NODE_MATH_COSH, "COSH", 0, "Hyperbolic Cosine", "cosh(A)"},
211 {NODE_MATH_TANH, "TANH", 0, "Hyperbolic Tangent", "tanh(A)"},
213 {NODE_MATH_RADIANS, "RADIANS", 0, "To Radians", "Convert from degrees to radians"},
214 {NODE_MATH_DEGREES, "DEGREES", 0, "To Degrees", "Convert from radians to degrees"},
215 {0, nullptr, 0, nullptr, nullptr},
216};
217
219 {NODE_VECTOR_MATH_ADD, "ADD", 0, "Add", "A + B"},
220 {NODE_VECTOR_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", "A - B"},
221 {NODE_VECTOR_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", "Entry-wise multiply"},
222 {NODE_VECTOR_MATH_DIVIDE, "DIVIDE", 0, "Divide", "Entry-wise divide"},
223 {NODE_VECTOR_MATH_MULTIPLY_ADD, "MULTIPLY_ADD", 0, "Multiply Add", "A * B + C"},
225 {NODE_VECTOR_MATH_CROSS_PRODUCT, "CROSS_PRODUCT", 0, "Cross Product", "A cross B"},
226 {NODE_VECTOR_MATH_PROJECT, "PROJECT", 0, "Project", "Project A onto B"},
228 "REFLECT",
229 0,
230 "Reflect",
231 "Reflect A around the normal B. B does not need to be normalized."},
233 "REFRACT",
234 0,
235 "Refract",
236 "For a given incident vector A, surface normal B and ratio of indices of refraction, Ior, "
237 "refract returns the refraction vector, R"},
239 "FACEFORWARD",
240 0,
241 "Faceforward",
242 "Orients a vector A to point away from a surface B as defined by its normal C. "
243 "Returns (dot(B, C) < 0) ? A : -A"},
244 {NODE_VECTOR_MATH_DOT_PRODUCT, "DOT_PRODUCT", 0, "Dot Product", "A dot B"},
246 {NODE_VECTOR_MATH_DISTANCE, "DISTANCE", 0, "Distance", "Distance between A and B"},
247 {NODE_VECTOR_MATH_LENGTH, "LENGTH", 0, "Length", "Length of A"},
248 {NODE_VECTOR_MATH_SCALE, "SCALE", 0, "Scale", "A multiplied by Scale"},
249 {NODE_VECTOR_MATH_NORMALIZE, "NORMALIZE", 0, "Normalize", "Normalize A"},
251 {NODE_VECTOR_MATH_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Entry-wise absolute"},
252 {NODE_VECTOR_MATH_POWER, "POWER", 0, "Power", "Entry-wise power"},
253 {NODE_VECTOR_MATH_SIGN, "SIGN", 0, "Sign", "Entry-wise sign"},
254 {NODE_VECTOR_MATH_MINIMUM, "MINIMUM", 0, "Minimum", "Entry-wise minimum"},
255 {NODE_VECTOR_MATH_MAXIMUM, "MAXIMUM", 0, "Maximum", "Entry-wise maximum"},
257 "ROUND",
258 0,
259 "Round",
260 "Entry-wise round to the nearest integer. Round upward if the fraction part is 0.5"},
261 {NODE_VECTOR_MATH_FLOOR, "FLOOR", 0, "Floor", "Entry-wise floor"},
262 {NODE_VECTOR_MATH_CEIL, "CEIL", 0, "Ceil", "Entry-wise ceil"},
263 {NODE_VECTOR_MATH_FRACTION, "FRACTION", 0, "Fraction", "The fraction part of A entry-wise"},
264 {NODE_VECTOR_MATH_MODULO, "MODULO", 0, "Modulo", "Entry-wise modulo using fmod(A,B)"},
265 {NODE_VECTOR_MATH_WRAP, "WRAP", 0, "Wrap", "Entry-wise wrap(A,B)"},
267 "SNAP",
268 0,
269 "Snap",
270 "Round A to the largest integer multiple of B less than or equal A"},
272 {NODE_VECTOR_MATH_SINE, "SINE", 0, "Sine", "Entry-wise sin(A)"},
273 {NODE_VECTOR_MATH_COSINE, "COSINE", 0, "Cosine", "Entry-wise cos(A)"},
274 {NODE_VECTOR_MATH_TANGENT, "TANGENT", 0, "Tangent", "Entry-wise tan(A)"},
275 {0, nullptr, 0, nullptr, nullptr},
276};
277
279 {NODE_BOOLEAN_MATH_AND, "AND", 0, "And", "True when both inputs are true"},
280 {NODE_BOOLEAN_MATH_OR, "OR", 0, "Or", "True when at least one input is true"},
281 {NODE_BOOLEAN_MATH_NOT, "NOT", 0, "Not", "Opposite of the input"},
283 {NODE_BOOLEAN_MATH_NAND, "NAND", 0, "Not And", "True when at least one input is false"},
284 {NODE_BOOLEAN_MATH_NOR, "NOR", 0, "Nor", "True when both inputs are false"},
286 "XNOR",
287 0,
288 "Equal",
289 "True when both inputs are equal (exclusive nor)"},
291 "XOR",
292 0,
293 "Not Equal",
294 "True when both inputs are different (exclusive or)"},
297 "IMPLY",
298 0,
299 "Imply",
300 "True unless the first input is true and the second is false"},
302 "NIMPLY",
303 0,
304 "Subtract",
305 "True when the first input is true and the second is false (not imply)"},
306 {0, nullptr, 0, nullptr, nullptr},
307};
308
311 {NODE_INTEGER_MATH_ADD, "ADD", 0, "Add", "A + B"},
312 {NODE_INTEGER_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", "A - B"},
313 {NODE_INTEGER_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", "A * B"},
314 {NODE_INTEGER_MATH_DIVIDE, "DIVIDE", 0, "Divide", "A / B"},
315 {NODE_INTEGER_MATH_MULTIPLY_ADD, "MULTIPLY_ADD", 0, "Multiply Add", "A * B + C"},
317 {NODE_INTEGER_MATH_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Non-negative value of A, abs(A)"},
318 {NODE_INTEGER_MATH_NEGATE, "NEGATE", 0, "Negate", "-A"},
319 {NODE_INTEGER_MATH_POWER, "POWER", 0, "Power", "A power B, pow(A,B)"},
322 "MINIMUM",
323 0,
324 "Minimum",
325 "The minimum value from A and B, min(A,B)"},
327 "MAXIMUM",
328 0,
329 "Maximum",
330 "The maximum value from A and B, max(A,B)"},
331 {NODE_INTEGER_MATH_SIGN, "SIGN", 0, "Sign", "Return the sign of A, sign(A)"},
334 "DIVIDE_ROUND",
335 0,
336 "Divide Round",
337 "Divide and round result toward zero"},
339 "DIVIDE_FLOOR",
340 0,
341 "Divide Floor",
342 "Divide and floor to the largest integer smaller than or equal to the result"},
344 "DIVIDE_CEIL",
345 0,
346 "Divide Ceiling",
347 "Divide and ceil to the smallest integer greater than or equal to the result"},
350 "FLOORED_MODULO",
351 0,
352 "Floored Modulo",
353 "Modulo that is periodic for both negative and positive operands"},
354 {NODE_INTEGER_MATH_MODULO, "MODULO", 0, "Modulo", "Modulo which is the remainder of A / B"},
357 "GCD",
358 0,
359 "Greatest Common Divisor",
360 "The largest positive integer that divides into each of the values A and B, "
361 "e.g. GCD(8,12) = 4"},
363 "LCM",
364 0,
365 "Least Common Multiple",
366 "The smallest positive integer that is divisible by both A and B, e.g. LCM(6,10) = 30"},
367 {0, nullptr, 0, nullptr, nullptr},
368};
369
372 "LESS_THAN",
373 0,
374 "Less Than",
375 "True when the first input is smaller than second input"},
377 "LESS_EQUAL",
378 0,
379 "Less Than or Equal",
380 "True when the first input is smaller than the second input or equal"},
382 "GREATER_THAN",
383 0,
384 "Greater Than",
385 "True when the first input is greater than the second input"},
387 "GREATER_EQUAL",
388 0,
389 "Greater Than or Equal",
390 "True when the first input is greater than the second input or equal"},
391 {NODE_COMPARE_EQUAL, "EQUAL", 0, "Equal", "True when both inputs are approximately equal"},
393 "NOT_EQUAL",
394 0,
395 "Not Equal",
396 "True when both inputs are not approximately equal"},
398 "BRIGHTER",
399 0,
400 "Brighter",
401 "True when the first input is brighter"},
402 {NODE_COMPARE_COLOR_DARKER, "DARKER", 0, "Darker", "True when the first input is darker"},
403 {0, nullptr, 0, nullptr, nullptr},
404};
405
408 "ROUND",
409 0,
410 "Round",
411 "Round the float up or down to the nearest integer"},
413 "FLOOR",
414 0,
415 "Floor",
416 "Round the float down to the next smallest integer"},
418 "CEILING",
419 0,
420 "Ceiling",
421 "Round the float up to the next largest integer"},
423 "TRUNCATE",
424 0,
425 "Truncate",
426 "Round the float to the closest integer in the direction of zero (floor if positive; ceiling "
427 "if negative)"},
428 {0, nullptr, 0, nullptr, nullptr},
429};
430
433 "LINEAR",
434 0,
435 "Linear",
436 "Linear interpolation between From Min and From Max values"},
438 "STEPPED",
439 0,
440 "Stepped Linear",
441 "Stepped linear interpolation between From Min and From Max values"},
443 "SMOOTHSTEP",
444 0,
445 "Smooth Step",
446 "Smooth Hermite edge interpolation between From Min and From Max values"},
448 "SMOOTHERSTEP",
449 0,
450 "Smoother Step",
451 "Smoother Hermite edge interpolation between From Min and From Max values"},
452 {0, nullptr, 0, nullptr, nullptr},
453};
454
456 {NODE_CLAMP_MINMAX, "MINMAX", 0, "Min Max", "Constrain value between min and max"},
458 "RANGE",
459 0,
460 "Range",
461 "Constrain value between min and max, swapping arguments when min > max"},
462 {0, nullptr, 0, nullptr, nullptr},
463};
464
466 {1, "1D", 0, "1D", "Use the scalar value W as input"},
467 {2, "2D", 0, "2D", "Use the 2D vector (X, Y) as input. The Z component is ignored."},
468 {3, "3D", 0, "3D", "Use the 3D vector (X, Y, Z) as input"},
469 {4, "4D", 0, "4D", "Use the 4D vector (X, Y, Z, W) as input"},
470 {0, nullptr, 0, nullptr, nullptr},
471};
472
475 "FREE",
476 ICON_HANDLE_FREE,
477 "Free",
478 "The handle can be moved anywhere, and does not influence the point's other handle"},
480 "AUTO",
481 ICON_HANDLE_AUTO,
482 "Auto",
483 "The location is automatically calculated to be smooth"},
485 "VECTOR",
486 ICON_HANDLE_VECTOR,
487 "Vector",
488 "The location is calculated to point to the next/previous control point"},
490 "ALIGN",
491 ICON_HANDLE_ALIGNED,
492 "Align",
493 "The location is constrained to point in the opposite direction as the other handle"},
494 {0, nullptr, 0, nullptr, nullptr}};
495
497 {GEO_NODE_CURVE_HANDLE_LEFT, "LEFT", ICON_NONE, "Left", "Use the left handles"},
498 {GEO_NODE_CURVE_HANDLE_RIGHT, "RIGHT", ICON_NONE, "Right", "Use the right handles"},
499 {0, nullptr, 0, nullptr, nullptr}};
500
503 "RGB",
504 ICON_NONE,
505 "RGB",
506 "Use RGB (Red, Green, Blue) color processing"},
508 "HSV",
509 ICON_NONE,
510 "HSV",
511 "Use HSV (Hue, Saturation, Value) color processing"},
513 "HSL",
514 ICON_NONE,
515 "HSL",
516 "Use HSL (Hue, Saturation, Lightness) color processing"},
517 {0, nullptr, 0, nullptr, nullptr},
518};
519
521 {SOCK_FLOAT, "FLOAT", ICON_NODE_SOCKET_FLOAT, "Float", ""},
522 {SOCK_VECTOR, "VECTOR", ICON_NODE_SOCKET_VECTOR, "Vector", ""},
523 {SOCK_RGBA, "RGBA", ICON_NODE_SOCKET_RGBA, "Color", ""},
524 {SOCK_ROTATION, "ROTATION", ICON_NODE_SOCKET_ROTATION, "Rotation", ""},
525 {0, nullptr, 0, nullptr, nullptr},
526};
527
529 {GEO_NODE_MESH_CIRCLE_FILL_NONE, "NONE", 0, "None", ""},
530 {GEO_NODE_MESH_CIRCLE_FILL_NGON, "NGON", 0, "N-Gon", ""},
531 {GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN, "TRIANGLE_FAN", 0, "Triangles", ""},
532 {0, nullptr, 0, nullptr, nullptr},
533};
534
536 {GEO_NODE_GIZMO_COLOR_PRIMARY, "PRIMARY", 0, "Primary", ""},
537 {GEO_NODE_GIZMO_COLOR_SECONDARY, "SECONDARY", 0, "Secondary", ""},
538 {GEO_NODE_GIZMO_COLOR_X, "X", 0, "X", ""},
539 {GEO_NODE_GIZMO_COLOR_Y, "Y", 0, "Y", ""},
540 {GEO_NODE_GIZMO_COLOR_Z, "Z", 0, "Z", ""},
541 {0, nullptr, 0, nullptr, nullptr},
542};
543
545 {GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_ARROW, "ARROW", 0, "Arrow", ""},
546 {GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_CROSS, "CROSS", 0, "Cross", ""},
547 {GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_BOX, "BOX", 0, "Box", ""},
548 {0, nullptr, 0, nullptr, nullptr},
549};
550
553 "CLIP",
554 0,
555 N_("Clip"),
556 N_("Areas outside of the image are filled with zero")},
558 "EXTEND",
559 0,
560 N_("Extend"),
561 N_("Areas outside of the image are filled with the closest boundary pixel in the image")},
563 "REPEAT",
564 0,
565 N_("Repeat"),
566 N_("Areas outside of the image are filled with repetitions of the image")},
567 {0, nullptr, 0, nullptr, nullptr},
568};
569
571 {CMP_NODE_INTERPOLATION_NEAREST, "NEAREST", 0, N_("Nearest"), N_("Use Nearest interpolation")},
573 "BILINEAR",
574 0,
575 N_("Bilinear"),
576 N_("Use Bilinear interpolation")},
578 "BICUBIC",
579 0,
580 N_("Bicubic"),
581 N_("Use Cubic B-Spline interpolation")},
583 "ANISOTROPIC",
584 0,
585 N_("Anisotropic"),
586 N_("Use Anisotropic interpolation")},
587 {0, nullptr, 0, nullptr, nullptr},
588};
589
592 "MERGE_BY_NAME",
593 0,
594 "By Name",
595 "Combine all layers which have the same name"},
597 "MERGE_BY_ID",
598 0,
599 "By Group ID",
600 "Provide a custom group ID for each layer and all layers with the same ID will be merged "
601 "into one"},
602 {0, nullptr, 0, nullptr, nullptr},
603};
604
607 "STROKE",
608 ICON_GP_DRAW_STROKE,
609 "Stroke",
610 "Set the color and opacity for the points of the stroke"},
612 "FILL",
613 ICON_GP_DRAW_FILL,
614 "Fill",
615 "Set the color and opacity for the stroke fills"},
617 "BOTH",
618 ICON_GP_DRAW_BOTH,
619 "Both",
620 "Set the color and opacity for stroke points and fills together"},
621 {0, nullptr, 0, nullptr, nullptr},
622};
623
626 "GEOMETRY",
627 0,
628 "Geometry",
629 "The attribute is associated with the object geometry, and its value "
630 "varies from vertex to vertex, or within the object volume"},
632 "OBJECT",
633 0,
634 "Object",
635 "The attribute is associated with the object or mesh data-block itself, "
636 "and its value is uniform"},
638 "INSTANCER",
639 0,
640 "Instancer",
641 "The attribute is associated with the instancer particle system or object, "
642 "falling back to the Object mode if the attribute isn't found, or the object "
643 "is not instanced"},
645 "VIEW_LAYER",
646 0,
647 "View Layer",
648 "The attribute is associated with the View Layer, Scene or World that is being rendered"},
650 "LIGHT",
651 0,
652 "Light",
653 "The attribute is associated with the Light that is being rendered"},
654 {0, nullptr, 0, nullptr, nullptr},
655};
656
658 {SHD_VECT_TRANSFORM_SPACE_WORLD, "WORLD", 0, "World", ""},
659 {SHD_VECT_TRANSFORM_SPACE_OBJECT, "OBJECT", 0, "Object", ""},
660 {SHD_VECT_TRANSFORM_SPACE_CAMERA, "CAMERA", 0, "Camera", ""},
661 {SHD_VECT_TRANSFORM_SPACE_LIGHT, "LIGHT", 0, "Light", ""},
662 {0, nullptr, 0, nullptr, nullptr},
663};
664
665#ifndef RNA_RUNTIME
666
669 "ALL",
670 0,
671 "All",
672 "Use shaders for all renderers and viewports, unless there exists a more specific output"},
673 {SHD_OUTPUT_EEVEE, "EEVEE", 0, "EEVEE", "Use shaders for EEVEE renderer"},
674 {SHD_OUTPUT_CYCLES, "CYCLES", 0, "Cycles", "Use shaders for Cycles renderer"},
675 {0, nullptr, 0, nullptr, nullptr},
676};
677
679 {0, "CryptoObject", 0, "Object", "Use Object layer"},
680 {1, "CryptoMaterial", 0, "Material", "Use Material layer"},
681 {2, "CryptoAsset", 0, "Asset", "Use Asset layer"},
682 {0, nullptr, 0, nullptr, nullptr},
683};
684
685#endif /* !RNA_RUNTIME */
686
687#undef ITEM_ATTRIBUTE
688#undef ITEM_FLOAT
689#undef ITEM_VECTOR
690#undef ITEM_COLOR
691#undef ITEM_BOOLEAN
692
693} // namespace blender
694
695#ifdef RNA_RUNTIME
696
697# include <fmt/format.h>
698
699# include "BLI_string.hh"
700# include "BLI_string_utf8.hh"
701
702# include "BKE_context.hh"
703# include "BKE_cryptomatte.hh"
704# include "BKE_global.hh"
705# include "BKE_image.hh"
706# include "BKE_layer.hh"
707# include "BKE_lib_id.hh"
708# include "BKE_main.hh"
709# include "BKE_main_invariants.hh"
710# include "BKE_node_legacy_types.hh"
711# include "BKE_node_runtime.hh"
712# include "BKE_node_tree_update.hh"
713# include "BKE_report.hh"
714# include "BKE_scene.hh"
715# include "BKE_texture.h"
716
717# include "BLF_api.hh"
718
719# include "ED_node.hh"
720# include "ED_render.hh"
721
722# include "GPU_material.hh"
723
724# include "NOD_common.hh"
725# include "NOD_composite.hh"
727# include "NOD_fn_format_string.hh"
728# include "NOD_geo_bake.hh"
729# include "NOD_geo_bundle.hh"
731# include "NOD_geo_closure.hh"
733# include "NOD_geo_combine_list.hh"
734# include "NOD_geo_field_to_grid.hh"
735# include "NOD_geo_field_to_list.hh"
737# include "NOD_geo_index_switch.hh"
738# include "NOD_geo_menu_switch.hh"
740# include "NOD_geo_repeat.hh"
741# include "NOD_geo_simulation.hh"
742# include "NOD_geo_viewer.hh"
743# include "NOD_geometry.hh"
745# include "NOD_rna_define.hh"
746# include "NOD_shader.h"
747# include "NOD_shader_raycast.hh"
748# include "NOD_socket.hh"
749# include "NOD_socket_items.hh"
750# include "NOD_texture.h"
751
752# include "RE_engine.h"
753# include "RE_pipeline.h"
754# include "RE_texture.h"
755
756# include "DNA_scene_types.h"
757# include "DNA_space_types.h"
758# include "DNA_text_types.h"
759
760# include "WM_api.hh"
761
762# include "DEG_depsgraph_query.hh"
763
764namespace blender {
765
790
791extern FunctionRNA *rna_NodeTree_poll_func;
792extern FunctionRNA *rna_NodeTree_update_func;
793extern FunctionRNA *rna_NodeTree_get_from_context_func;
794extern FunctionRNA *rna_NodeTree_valid_socket_type_func;
795extern FunctionRNA *rna_Node_poll_func;
796extern FunctionRNA *rna_Node_poll_instance_func;
797extern FunctionRNA *rna_Node_update_func;
798extern FunctionRNA *rna_Node_insert_link_func;
799extern FunctionRNA *rna_Node_init_func;
800extern FunctionRNA *rna_Node_copy_func;
801extern FunctionRNA *rna_Node_free_func;
802extern FunctionRNA *rna_Node_draw_buttons_func;
803extern FunctionRNA *rna_Node_draw_buttons_ext_func;
804extern FunctionRNA *rna_Node_draw_label_func;
805
806void rna_Node_socket_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr);
807
808int rna_node_tree_idname_to_enum(const char *idname)
809{
811 for (const int i : types.index_range()) {
812 const bke::bNodeTreeType *nt = types[i];
813 if (nt->idname == idname) {
814 return i;
815 }
816 }
817 return -1;
818}
819
821{
823 return types.index_range().contains(value) ? types[value] : nullptr;
824}
825
827 bool (*poll)(void *data, bke::bNodeTreeType *),
828 bool *r_free)
829{
830 EnumPropertyItem tmp = {0};
831 EnumPropertyItem *item = nullptr;
832 int totitem = 0;
833
835 for (const int i : types.index_range()) {
836 bke::bNodeTreeType *nt = types[i];
837 if (poll && !poll(data, nt)) {
838 continue;
839 }
840
841 tmp.value = i;
842 tmp.identifier = nt->idname.c_str();
843 tmp.icon = nt->ui_icon;
844 tmp.name = nt->ui_name.c_str();
845 tmp.description = nt->ui_description.c_str();
846
847 RNA_enum_item_add(&item, &totitem, &tmp);
848 }
849
850 if (totitem == 0) {
851 *r_free = false;
853 }
854
855 RNA_enum_item_end(&item, &totitem);
856 *r_free = true;
857
858 return item;
859}
860
861int rna_node_socket_idname_to_enum(const char *idname)
862{
864 if (socket_type == nullptr) {
865 /* May happen when reading newer files with undefined types. In this case the socket is
866 * undefined and no enum item will be selected. */
867 return -1;
868 }
869
870 /* Regular socket types use the base type as their enum value.
871 * Custom sockets don't have a base type and are used directly as the enum entry. */
872 if (socket_type->type == SOCK_CUSTOM) {
873 return bke::node_socket_types_get().first_index(socket_type);
874 }
875
876 bke::bNodeSocketType *base_socket_type = bke::node_socket_type_find_static(socket_type->type,
877 PROP_NONE);
878 BLI_assert(base_socket_type != nullptr);
879 return bke::node_socket_types_get().first_index(base_socket_type);
880}
881
883{
885 return types.index_range().contains(value) ? types[value] : nullptr;
886}
887
889 void *data, bool (*poll)(void *data, bke::bNodeSocketType *), bool *r_free)
890{
891 EnumPropertyItem *item = nullptr;
892 EnumPropertyItem tmp = {0};
893 int totitem = 0;
894 StructRNA *srna;
895
897 for (const int i : types.index_range()) {
898 bke::bNodeSocketType *stype = types[i];
899 if (poll && !poll(data, stype)) {
900 continue;
901 }
902
903 srna = stype->ext_socket.srna;
904 tmp.value = i;
905 tmp.identifier = stype->idname.c_str();
906 tmp.icon = RNA_struct_ui_icon(srna);
907 tmp.name = bke::node_socket_type_label(*stype).c_str();
908 tmp.description = RNA_struct_ui_description(srna);
909
910 RNA_enum_item_add(&item, &totitem, &tmp);
911 }
912
913 if (totitem == 0) {
914 *r_free = false;
916 }
917
918 RNA_enum_item_end(&item, &totitem);
919 *r_free = true;
920
921 return item;
922}
923
924static const char *get_legacy_node_type(const PointerRNA *ptr)
925{
926 const bNode *node = ptr->data_as<bNode>();
927 const bke::bNodeType *ntype = node->typeinfo;
928 if (ntype->type_legacy == NODE_CUSTOM) {
929 return "CUSTOM";
930 }
931 if (ntype->type_legacy == NODE_CUSTOM_GROUP) {
932 return "CUSTOM GROUP";
933 }
934 if (ntype->type_legacy == NODE_UNDEFINED) {
935 return "UNDEFINED";
936 }
937 if (ntype->enum_name_legacy) {
938 return ntype->enum_name_legacy;
939 }
940 return ntype->idname.c_str();
941}
942
943static int rna_node_type_length(PointerRNA *ptr)
944{
945 const char *legacy_type = get_legacy_node_type(ptr);
946 BLI_assert(legacy_type);
947 return strlen(legacy_type);
948}
949
950static void rna_node_type_get(PointerRNA *ptr, char *value)
951{
952 const char *legacy_type = get_legacy_node_type(ptr);
953 BLI_assert(legacy_type);
954 strcpy(value, legacy_type);
955}
956
957static void rna_Node_bl_idname_get(PointerRNA *ptr, char *value)
958{
959 const bNode *node = ptr->data_as<bNode>();
960 const bke::bNodeType *ntype = node->typeinfo;
961 ntype->idname.ref().copy_unsafe(value);
962}
963
964static int rna_Node_bl_idname_length(PointerRNA *ptr)
965{
966 const bNode *node = ptr->data_as<bNode>();
967 const bke::bNodeType *ntype = node->typeinfo;
968 return ntype->idname.size();
969}
970
971static void rna_Node_bl_idname_set(PointerRNA *ptr, const char *value)
972{
973 bNode *node = ptr->data_as<bNode>();
974 bke::bNodeType *ntype = node->typeinfo;
975 ntype->idname = UString(value);
976}
977
978static void rna_Node_bl_label_get(PointerRNA *ptr, char *value)
979{
980 const bNode *node = ptr->data_as<bNode>();
981 const bke::bNodeType *ntype = node->typeinfo;
982 StringRef(ntype->ui_name).copy_unsafe(value);
983}
984
985static int rna_Node_bl_label_length(PointerRNA *ptr)
986{
987 const bNode *node = ptr->data_as<bNode>();
988 const bke::bNodeType *ntype = node->typeinfo;
989 return ntype->ui_name.size();
990}
991
992static void rna_Node_bl_label_set(PointerRNA *ptr, const char *value)
993{
994 bNode *node = ptr->data_as<bNode>();
995 bke::bNodeType *ntype = node->typeinfo;
996 ntype->ui_name = value;
997}
998
999static void rna_Node_bl_description_get(PointerRNA *ptr, char *value)
1000{
1001 const bNode *node = ptr->data_as<bNode>();
1002 const bke::bNodeType *ntype = node->typeinfo;
1003 StringRef(ntype->ui_description).copy_unsafe(value);
1004}
1005
1006static int rna_Node_bl_description_length(PointerRNA *ptr)
1007{
1008 const bNode *node = ptr->data_as<bNode>();
1009 const bke::bNodeType *ntype = node->typeinfo;
1010 return ntype->ui_description.size();
1011}
1012
1013static void rna_Node_bl_description_set(PointerRNA *ptr, const char *value)
1014{
1015 bNode *node = ptr->data_as<bNode>();
1016 bke::bNodeType *ntype = node->typeinfo;
1017 ntype->ui_description = value;
1018}
1019
1020static float2 node_parent_offset(const bNode &node)
1021{
1022 return node.parent ? float2(node.parent->location[0], node.parent->location[1]) : float2(0);
1023}
1024
1025static void rna_Node_location_get(PointerRNA *ptr, float *value)
1026{
1027 const bNode *node = ptr->data_as<bNode>();
1028 copy_v2_v2(value, float2(node->location[0], node->location[1]) - node_parent_offset(*node));
1029}
1030
1031static void move_child_nodes(bNode &node, const float2 &delta)
1032{
1033 for (bNode *child : node.direct_children_in_frame()) {
1034 child->location[0] += delta.x;
1035 child->location[1] += delta.y;
1036 if (child->is_frame()) {
1037 move_child_nodes(*child, delta);
1038 }
1039 }
1040}
1041
1042static void rna_Node_location_set(PointerRNA *ptr, const float *value)
1043{
1044 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
1045 bNode *node = ptr->data_as<bNode>();
1046
1047 ntree->ensure_topology_cache();
1048 const float2 new_location = float2(value) + node_parent_offset(*node);
1049 if (node->is_frame()) {
1050 move_child_nodes(*node, new_location - float2(node->location[0], node->location[1]));
1051 }
1052 node->location[0] = new_location.x;
1053 node->location[1] = new_location.y;
1054}
1055
1056/* ******** Node Tree ******** */
1057
1058static StructRNA *rna_NodeTree_refine(PointerRNA *ptr)
1059{
1060 bNodeTree *ntree = ptr->data_as<bNodeTree>();
1061
1062 if (ntree->typeinfo->rna_ext.srna) {
1063 return ntree->typeinfo->rna_ext.srna;
1064 }
1065 else {
1066 return RNA_NodeTree;
1067 }
1068}
1069
1070static bool rna_NodeTree_poll(const bContext *C, bke::bNodeTreeType *ntreetype)
1071{
1073 FunctionRNA *func;
1074 void *ret;
1075 bool visible;
1076
1078 nullptr, ntreetype->rna_ext.srna, nullptr); /* dummy */
1079 func = rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1080
1081 RNA_parameter_list_create(&list, &ptr, func);
1082 RNA_parameter_set_lookup(&list, "context", &C);
1083 ntreetype->rna_ext.call(const_cast<bContext *>(C), &ptr, func, &list);
1084
1085 RNA_parameter_get_lookup(&list, "visible", &ret);
1086 visible = *static_cast<bool *>(ret);
1087
1089
1090 return visible;
1091}
1092
1093static void rna_NodeTree_update_reg(bNodeTree *ntree)
1094{
1096 FunctionRNA *func;
1097
1098 PointerRNA ptr = RNA_id_pointer_create(&ntree->id);
1099 func = rna_NodeTree_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1100
1101 RNA_parameter_list_create(&list, &ptr, func);
1102 ntree->typeinfo->rna_ext.call(nullptr, &ptr, func, &list);
1103
1105}
1106
1107static void rna_NodeTree_get_from_context(
1108 const bContext *C, bke::bNodeTreeType *ntreetype, bNodeTree **r_ntree, ID **r_id, ID **r_from)
1109{
1111 FunctionRNA *func;
1112 void *ret1, *ret2, *ret3;
1113
1115 nullptr, ntreetype->rna_ext.srna, nullptr); /* dummy */
1116 // RNA_struct_find_function(&ptr, "get_from_context");
1117 func = rna_NodeTree_get_from_context_func;
1118
1119 RNA_parameter_list_create(&list, &ptr, func);
1120 RNA_parameter_set_lookup(&list, "context", &C);
1121 ntreetype->rna_ext.call(const_cast<bContext *>(C), &ptr, func, &list);
1122
1123 RNA_parameter_get_lookup(&list, "result_1", &ret1);
1124 RNA_parameter_get_lookup(&list, "result_2", &ret2);
1125 RNA_parameter_get_lookup(&list, "result_3", &ret3);
1126 *r_ntree = *static_cast<bNodeTree **>(ret1);
1127 *r_id = *static_cast<ID **>(ret2);
1128 *r_from = *static_cast<ID **>(ret3);
1129
1131}
1132
1133static bool rna_NodeTree_valid_socket_type(bke::bNodeTreeType *ntreetype,
1134 bke::bNodeSocketType *socket_type)
1135{
1137 FunctionRNA *func;
1138 void *ret;
1139 bool valid;
1140
1142 nullptr, ntreetype->rna_ext.srna, nullptr); /* dummy */
1143 func = rna_NodeTree_valid_socket_type_func;
1144
1145 RNA_parameter_list_create(&list, &ptr, func);
1146 RNA_parameter_set_lookup(&list, "idname", socket_type->idname.c_str());
1147 ntreetype->rna_ext.call(nullptr, &ptr, func, &list);
1148
1149 RNA_parameter_get_lookup(&list, "valid", &ret);
1150 valid = *static_cast<bool *>(ret);
1151
1153
1154 return valid;
1155}
1156
1157static bool rna_NodeTree_unregister(Main *bmain, StructRNA *type)
1158{
1160
1161 if (!nt) {
1162 return false;
1163 }
1165
1166 RNA_struct_free_extension(type, &nt->rna_ext);
1168
1170
1171 /* update while blender is running */
1174 return true;
1175}
1176
1177static StructRNA *rna_NodeTree_register(Main *bmain,
1178 ReportList *reports,
1179 void *data,
1180 const char *identifier,
1181 StructValidateFunc validate,
1182 StructCallbackFunc call,
1184{
1186 bNodeTree dummy_ntree = {};
1187 bool have_function[4];
1188
1189 /* setup dummy tree & tree type to store static properties in */
1190 bke::bNodeTreeType dummy_nt = {};
1191 dummy_ntree.typeinfo = &dummy_nt;
1192 PointerRNA dummy_ntree_ptr = RNA_pointer_create_discrete(nullptr, RNA_NodeTree, &dummy_ntree);
1193
1194 /* validate the python class */
1195 if (validate(&dummy_ntree_ptr, data, have_function) != 0) {
1196 return nullptr;
1197 }
1198
1199 if (strlen(identifier) >= sizeof(dummy_ntree.idname)) {
1200 BKE_reportf(reports,
1201 RPT_ERROR,
1202 "Registering node tree class: '%s' is too long, maximum length is %d",
1203 identifier,
1204 int(sizeof(dummy_ntree.idname)));
1205 return nullptr;
1206 }
1207
1208 /* check if we have registered this tree type before, and remove it */
1209 nt = bke::node_tree_type_find(dummy_nt.idname.ref());
1210 if (nt) {
1211 BKE_reportf(reports,
1212 RPT_INFO,
1213 "Registering node tree class: '%s', bl_idname '%s' has been registered before, "
1214 "unregistering previous",
1215 identifier,
1216 dummy_nt.idname.c_str());
1217
1218 /* NOTE: unlike most types `nt->rna_ext.srna` doesn't need to be checked for nullptr. */
1219 if (!rna_NodeTree_unregister(bmain, nt->rna_ext.srna)) {
1220 BKE_reportf(reports,
1221 RPT_ERROR,
1222 "Registering node tree class: '%s', bl_idname '%s' could not be unregistered",
1223 identifier,
1224 dummy_nt.idname.c_str());
1225 return nullptr;
1226 }
1227 }
1228
1229 /* create a new node tree type */
1230 nt = MEM_new<bke::bNodeTreeType>(__func__, dummy_nt);
1231
1232 nt->type = NTREE_CUSTOM;
1233
1234 nt->rna_ext.srna = RNA_def_struct_ptr(&RNA_blender_rna_get(), nt->idname.c_str(), RNA_NodeTree);
1235 nt->rna_ext.data = data;
1236 nt->rna_ext.call = call;
1237 nt->rna_ext.free = free;
1238 RNA_struct_blender_type_set(nt->rna_ext.srna, nt);
1239
1240 RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name.c_str(), nt->ui_description.c_str());
1241 RNA_def_struct_ui_icon(nt->rna_ext.srna, nt->ui_icon);
1242
1243 nt->poll = (have_function[0]) ? rna_NodeTree_poll : nullptr;
1244 nt->update = (have_function[1]) ? rna_NodeTree_update_reg : nullptr;
1245 nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : nullptr;
1246 nt->valid_socket_type = (have_function[3]) ? rna_NodeTree_valid_socket_type : nullptr;
1247
1249
1250 /* update while blender is running */
1253 return nt->rna_ext.srna;
1254}
1255
1256static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports)
1257{
1258 if (!bke::node_tree_is_registered(*ntree)) {
1259 if (reports) {
1260 BKE_reportf(reports,
1261 RPT_ERROR,
1262 "Node tree '%s' has undefined type %s",
1263 ntree->id.name + 2,
1264 ntree->idname);
1265 }
1266 return false;
1267 }
1268 else {
1269 return true;
1270 }
1271}
1272
1273static void rna_NodeTree_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
1274{
1275 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
1276
1277 WM_main_add_notifier(NC_NODE | NA_EDITED, &ntree->id);
1278 WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
1279
1280 BKE_main_ensure_invariants(*bmain, ntree->id);
1281}
1282
1283static void rna_NodeTree_update_asset(Main *bmain, Scene *scene, PointerRNA *ptr)
1284{
1285 rna_NodeTree_update(bmain, scene, ptr);
1287 bke::node_update_asset_metadata(*reinterpret_cast<bNodeTree *>(ptr->owner_id));
1288}
1289
1290static const EnumPropertyItem *rna_NodeTree_color_tag_itemf(bContext * /*C*/,
1291 PointerRNA *ptr,
1292 PropertyRNA * /*prop*/,
1293 bool *r_free)
1294{
1295 const bNodeTree &ntree = *reinterpret_cast<const bNodeTree *>(ptr->owner_id);
1296
1297 EnumPropertyItem *items = nullptr;
1298 int items_num = 0;
1299
1300 for (const EnumPropertyItem *item = rna_enum_node_color_tag_items; item->identifier; item++) {
1301 switch (bke::NodeColorTag(item->value)) {
1304 if (ntree.type == NTREE_GEOMETRY) {
1305 RNA_enum_item_add(&items, &items_num, item);
1306 }
1307 break;
1308 }
1311 if (ntree.type == NTREE_SHADER) {
1312 RNA_enum_item_add(&items, &items_num, item);
1313 }
1314 break;
1315 }
1319 if (ntree.type == NTREE_COMPOSIT) {
1320 RNA_enum_item_add(&items, &items_num, item);
1321 }
1322 break;
1323 }
1327 break;
1328 }
1329 default: {
1330 RNA_enum_item_add(&items, &items_num, item);
1331 break;
1332 }
1333 }
1334 }
1335
1336 RNA_enum_item_end(&items, &items_num);
1337
1338 *r_free = true;
1339 return items;
1340}
1341
1342static bNode *rna_NodeTree_node_new(bNodeTree *ntree,
1343 bContext *C,
1344 ReportList *reports,
1345 StringRefNull type)
1346{
1347 bke::bNodeType *ntype;
1348 bNode *node;
1349
1350 if (!rna_NodeTree_check(ntree, reports)) {
1351 return nullptr;
1352 }
1353
1354 /* If the given idname is an alias, translate it to the proper idname. */
1355 type = bke::node_type_find_alias(UString(type)).ref();
1356
1357 ntype = bke::node_type_find(UString(type));
1358 if (!ntype) {
1359 BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type.c_str());
1360 return nullptr;
1361 }
1362
1363 const char *disabled_hint = nullptr;
1364 if (ntype->poll && !ntype->poll(ntype, ntree, &disabled_hint)) {
1365 if (disabled_hint) {
1366 BKE_reportf(reports,
1367 RPT_ERROR,
1368 "Cannot add node of type %s to node tree '%s'\n %s",
1369 type.c_str(),
1370 ntree->id.name + 2,
1371 disabled_hint);
1372 return nullptr;
1373 }
1374 else {
1375 BKE_reportf(reports,
1376 RPT_ERROR,
1377 "Cannot add node of type %s to node tree '%s'",
1378 type.c_str(),
1379 ntree->id.name + 2);
1380 return nullptr;
1381 }
1382 }
1383
1384 node = bke::node_add_node(C, *ntree, UString(type));
1385 BLI_assert(node && node->typeinfo);
1386
1387 if (ntree->type == NTREE_TEXTURE) {
1388 ntreeTexCheckCyclics(ntree);
1389 }
1390
1391 Main *bmain = CTX_data_main(C);
1392 BKE_main_ensure_invariants(*bmain, ntree->id);
1394
1395 return node;
1396}
1397
1398static void rna_NodeTree_node_remove(bNodeTree *ntree,
1399 Main *bmain,
1400 ReportList *reports,
1401 PointerRNA *node_ptr)
1402{
1403 bNode *node = node_ptr->data_as<bNode>();
1404
1405 if (!rna_NodeTree_check(ntree, reports)) {
1406 return;
1407 }
1408
1409 if (BLI_findindex(&ntree->nodes, node) == -1) {
1410 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
1411 return;
1412 }
1413
1414 bke::node_remove_node(bmain, *ntree, *node, true);
1415
1416 node_ptr->invalidate();
1417
1418 BKE_main_ensure_invariants(*bmain, ntree->id);
1420}
1421
1422static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1423{
1424 bNode *node = ntree->nodes.first();
1425
1426 if (!rna_NodeTree_check(ntree, reports)) {
1427 return;
1428 }
1429
1430 while (node) {
1431 bNode *next_node = node->next;
1432
1433 bke::node_remove_node(bmain, *ntree, *node, true);
1434
1435 node = next_node;
1436 }
1437
1438 BKE_main_ensure_invariants(*bmain, ntree->id);
1440}
1441
1442static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
1443{
1444 bNodeTree *ntree = ptr->data_as<bNodeTree>();
1445 bNode *node = bke::node_get_active(*ntree);
1446 return RNA_pointer_create_with_parent(*ptr, RNA_Node, node);
1447}
1448
1449static void rna_NodeTree_active_node_set(PointerRNA *ptr,
1450 const PointerRNA value,
1451 ReportList * /*reports*/)
1452{
1453 bNodeTree *ntree = ptr->data_as<bNodeTree>();
1454 bNode *node = static_cast<bNode *>(value.data);
1455
1456 if (node && BLI_findindex(&ntree->nodes, node) != -1) {
1457 bke::node_set_active(*ntree, *node);
1458
1459 /* Handle NODE_DO_OUTPUT as well. */
1460 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT && node->type_legacy != CMP_NODE_OUTPUT_FILE) {
1461 /* If this node becomes the active output, the others of the same type can't be the active
1462 * output anymore. */
1463 for (bNode *other_node : ntree->all_nodes()) {
1464 if (other_node->type_legacy == node->type_legacy) {
1465 other_node->flag &= ~NODE_DO_OUTPUT;
1466 }
1467 }
1468 node->flag |= NODE_DO_OUTPUT;
1471 }
1472 }
1473 else {
1474 bke::node_clear_active(*ntree);
1475 }
1476}
1477
1478static void node_viewer_set_shortcut_fn(bNode *node, bNodeTree &ntree, int value)
1479{
1480 /* Avoid having two nodes with the same shortcut. */
1481 for (bNode *other_node : ntree.all_nodes()) {
1482 if ((other_node->is_type("CompositorNodeViewer"_ustr) ||
1483 other_node->is_type("GeometryNodeViewer"_ustr)) &&
1484 other_node->custom1 == value)
1485 {
1486 other_node->custom1 = NODE_VIEWER_SHORTCUT_NONE;
1487 }
1488 }
1489 node->custom1 = value;
1490}
1491
1492void rna_Node_Viewer_shortcut_node_set(PointerRNA *ptr, PropertyRNA * /*prop*/, int value)
1493{
1494 bNode *curr_node = ptr->data_as<bNode>();
1495 bNodeTree &ntree = curr_node->owner_tree();
1496
1497 node_viewer_set_shortcut_fn(curr_node, ntree, value);
1498}
1499
1501{
1502 bNode *curr_node = ptr->data_as<bNode>();
1503 bNodeTree &ntree = curr_node->owner_tree();
1504
1505 node_viewer_set_shortcut_fn(curr_node, ntree, value);
1506}
1507
1508static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree,
1509 Main *bmain,
1510 ReportList *reports,
1511 bNodeSocket *fromsock,
1512 bNodeSocket *tosock,
1513 bool verify_limits,
1514 bool handle_dynamic_sockets)
1515{
1516 if (!rna_NodeTree_check(ntree, reports)) {
1517 return nullptr;
1518 }
1519
1520 bNode *fromnode = bke::node_find_node_try(*ntree, *fromsock);
1521 bNode *tonode = bke::node_find_node_try(*ntree, *tosock);
1522 /* check validity of the sockets:
1523 * if sockets from different trees are passed in this will fail!
1524 */
1525 if (!fromnode || !tonode) {
1526 return nullptr;
1527 }
1528
1529 if (fromsock->in_out == tosock->in_out) {
1530 BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
1531 return nullptr;
1532 }
1533
1534 if (fromsock->in_out == SOCK_IN) {
1535 std::swap(fromsock, tosock);
1536 std::swap(fromnode, tonode);
1537 }
1538
1539 if (handle_dynamic_sockets) {
1540 bNodeLink new_link{};
1541 new_link.fromnode = fromnode;
1542 new_link.fromsock = fromsock;
1543 new_link.tonode = tonode;
1544 new_link.tosock = tosock;
1545
1546 if (fromnode->typeinfo->insert_link) {
1547 bke::NodeInsertLinkParams params{*ntree, *fromnode, new_link};
1548 if (!fromnode->typeinfo->insert_link(params)) {
1549 return nullptr;
1550 }
1551 }
1552 if (tonode->typeinfo->insert_link) {
1553 bke::NodeInsertLinkParams params{*ntree, *tonode, new_link};
1554 if (!tonode->typeinfo->insert_link(params)) {
1555 return nullptr;
1556 }
1557 }
1558
1559 fromsock = new_link.fromsock;
1560 tosock = new_link.tosock;
1561 }
1562
1563 if (verify_limits) {
1564 /* remove other socket links if limit is exceeded */
1565 if (bke::node_count_socket_links(*ntree, *fromsock) + 1 >
1566 bke::node_socket_link_limit(*fromsock))
1567 {
1568 bke::node_remove_socket_links(*ntree, *fromsock);
1569 }
1570 if (bke::node_count_socket_links(*ntree, *tosock) + 1 > bke::node_socket_link_limit(*tosock)) {
1571 bke::node_remove_socket_links(*ntree, *tosock);
1572 }
1573 if (tosock->flag & SOCK_MULTI_INPUT) {
1574 for (bNodeLink &link : ntree->links.items_mutable()) {
1575 if (link.fromsock == fromsock && link.tosock == tosock) {
1576 bke::node_remove_link(ntree, link);
1577 }
1578 }
1579 }
1580 }
1581
1582 bNodeLink &ret = bke::node_add_link(*ntree, *fromnode, *fromsock, *tonode, *tosock);
1583
1584 /* not an issue from the UI, clear hidden from API to keep valid state. */
1585 fromsock->flag &= ~SOCK_HIDDEN;
1586 tosock->flag &= ~SOCK_HIDDEN;
1587
1588 BKE_main_ensure_invariants(*bmain, ntree->id);
1590
1591 return &ret;
1592}
1593
1594static void rna_NodeTree_link_remove(bNodeTree *ntree,
1595 Main *bmain,
1596 ReportList *reports,
1597 PointerRNA *link_ptr)
1598{
1599 bNodeLink *link = link_ptr->data_as<bNodeLink>();
1600
1601 if (!rna_NodeTree_check(ntree, reports)) {
1602 return;
1603 }
1604
1605 if (BLI_findindex(&ntree->links, link) == -1) {
1606 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
1607 return;
1608 }
1609
1610 bke::node_remove_link(ntree, *link);
1611 link_ptr->invalidate();
1612
1613 BKE_main_ensure_invariants(*bmain, ntree->id);
1615}
1616
1617static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1618{
1619 bNodeLink *link = ntree->links.first();
1620
1621 if (!rna_NodeTree_check(ntree, reports)) {
1622 return;
1623 }
1624
1625 while (link) {
1626 bNodeLink *next_link = link->next;
1627
1628 bke::node_remove_link(ntree, *link);
1629
1630 link = next_link;
1631 }
1632 BKE_main_ensure_invariants(*bmain, ntree->id);
1634}
1635
1636static bool rna_NodeTree_contains_tree(bNodeTree *tree, bNodeTree *sub_tree)
1637{
1638 return bke::node_tree_contains_tree(*tree, *sub_tree);
1639}
1640
1641static void rna_NodeTree_bl_idname_get(PointerRNA *ptr, char *value)
1642{
1643 const bNodeTree *node = ptr->data_as<bNodeTree>();
1644 const bke::bNodeTreeType *ntype = node->typeinfo;
1645 ntype->idname.ref().copy_unsafe(value);
1646}
1647
1648static int rna_NodeTree_bl_idname_length(PointerRNA *ptr)
1649{
1650 const bNodeTree *node = ptr->data_as<bNodeTree>();
1651 const bke::bNodeTreeType *ntype = node->typeinfo;
1652 return ntype->idname.size();
1653}
1654
1655static void rna_NodeTree_bl_idname_set(PointerRNA *ptr, const char *value)
1656{
1657 bNodeTree *node = ptr->data_as<bNodeTree>();
1658 bke::bNodeTreeType *ntype = node->typeinfo;
1659 ntype->idname = UString(value);
1660}
1661
1662static void rna_NodeTree_bl_label_get(PointerRNA *ptr, char *value)
1663{
1664 const bNodeTree *node = ptr->data_as<bNodeTree>();
1665 const bke::bNodeTreeType *ntype = node->typeinfo;
1666 StringRef(ntype->ui_name).copy_unsafe(value);
1667}
1668
1669static int rna_NodeTree_bl_label_length(PointerRNA *ptr)
1670{
1671 const bNodeTree *node = ptr->data_as<bNodeTree>();
1672 const bke::bNodeTreeType *ntype = node->typeinfo;
1673 return ntype->ui_name.size();
1674}
1675
1676static void rna_NodeTree_bl_label_set(PointerRNA *ptr, const char *value)
1677{
1678 bNodeTree *node = ptr->data_as<bNodeTree>();
1679 bke::bNodeTreeType *ntype = node->typeinfo;
1680 ntype->ui_name = value;
1681}
1682
1683static void rna_NodeTree_bl_description_get(PointerRNA *ptr, char *value)
1684{
1685 const bNodeTree *node = ptr->data_as<bNodeTree>();
1686 const bke::bNodeTreeType *ntype = node->typeinfo;
1687 StringRef(ntype->ui_description).copy_unsafe(value);
1688}
1689
1690static int rna_NodeTree_bl_description_length(PointerRNA *ptr)
1691{
1692 const bNodeTree *node = ptr->data_as<bNodeTree>();
1693 const bke::bNodeTreeType *ntype = node->typeinfo;
1694 return ntype->ui_description.size();
1695}
1696
1697static void rna_NodeTree_bl_description_set(PointerRNA *ptr, const char *value)
1698{
1699 bNodeTree *node = ptr->data_as<bNodeTree>();
1700 bke::bNodeTreeType *ntype = node->typeinfo;
1701 ntype->ui_description = value;
1702}
1703
1704static void rna_NodeTree_debug_lazy_function_graph(bNodeTree *tree,
1705 bContext *C,
1706 const char **r_str,
1707 int *r_len)
1708{
1709 *r_len = 0;
1710 *r_str = nullptr;
1711 if (DEG_is_original(tree)) {
1712 /* The graph is only stored on the evaluated data. */
1713 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
1714 tree = DEG_get_evaluated(depsgraph, tree);
1715 };
1716 if (tree->runtime->geometry_nodes_lazy_function_graph_info_mutex.is_dirty()) {
1717 return;
1718 }
1719 std::string dot_str = tree->runtime->geometry_nodes_lazy_function_graph_info->graph.to_dot();
1720 *r_str = BLI_strdup(dot_str.c_str());
1721 *r_len = dot_str.size();
1722}
1723
1724static void rna_NodeTree_debug_zone_body_lazy_function_graph(
1725 ID *tree_id, bNode *node, bContext *C, const char **r_str, int *r_len)
1726{
1727 *r_len = 0;
1728 *r_str = nullptr;
1729 bNodeTree *tree = reinterpret_cast<bNodeTree *>(tree_id);
1730 if (DEG_is_original(tree)) {
1731 /* The graph is only stored on the evaluated data. */
1732 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
1733 tree = DEG_get_evaluated(depsgraph, tree);
1734 }
1735 if (tree->runtime->geometry_nodes_lazy_function_graph_info_mutex.is_dirty()) {
1736 return;
1737 }
1738 const auto *graph = tree->runtime->geometry_nodes_lazy_function_graph_info
1739 ->debug_zone_body_graphs.lookup_default(node->identifier, nullptr);
1740 if (!graph) {
1741 return;
1742 }
1743 std::string dot_str = graph->to_dot();
1744 *r_str = BLI_strdup(dot_str.c_str());
1745 *r_len = dot_str.size();
1746}
1747
1748static void rna_NodeTree_debug_zone_lazy_function_graph(
1749 ID *tree_id, bNode *node, bContext *C, const char **r_str, int *r_len)
1750{
1751 *r_len = 0;
1752 *r_str = nullptr;
1753 Main *bmain = CTX_data_main(C);
1754 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
1755 bNodeTree *tree = reinterpret_cast<bNodeTree *>(tree_id);
1756
1757 if (tree->type != NTREE_GEOMETRY) {
1758 return;
1759 }
1760 /* By creating this data we tell the evaluation that we want to log it. */
1761 tree->runtime->logged_zone_graphs = std::make_unique<bke::LoggedZoneGraphs>();
1762 BLI_SCOPED_DEFER([&]() { tree->runtime->logged_zone_graphs.reset(); })
1763
1764 /* Make sure that dependencies of this tree will be evaluated. */
1766 /* Actually do evaluation. */
1767 BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
1768
1769 /* Get logged graph if it was evaluated. */
1770 std::optional<std::string> dot_str = tree->runtime->logged_zone_graphs->graph_by_zone_id.pop_try(
1771 node->identifier);
1772 if (!dot_str) {
1773 return;
1774 }
1775 *r_str = BLI_strdup(dot_str->c_str());
1776 *r_len = dot_str->size();
1777}
1778
1779static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1780{
1781 Main *bmain = CTX_data_main(C);
1782 ntree->tree_interface.tag_items_changed_generic();
1783 BKE_main_ensure_invariants(*bmain, ntree->id);
1784}
1785
1786/* ******** NodeLink ******** */
1787
1788static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1789{
1790 bNodeLink *link = static_cast<bNodeLink *>(ptr->data);
1791 return bke::node_link_is_hidden(*link);
1792}
1793
1794static void rna_NodeLink_swap_multi_input_sort_id(
1795 ID *id, bNodeLink *self, Main *bmain, ReportList *reports, bNodeLink *other)
1796{
1797 if (self->tosock != other->tosock) {
1798 BKE_report(reports, RPT_ERROR_INVALID_INPUT, "The links must be siblings");
1799 return;
1800 }
1801
1802 std::swap(self->multi_input_sort_id, other->multi_input_sort_id);
1803
1804 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
1806 BKE_main_ensure_invariants(*bmain, ntree->id);
1808}
1809
1810/* ******** Node ******** */
1811
1812static StructRNA *rna_Node_refine(PointerRNA *ptr)
1813{
1814 bNode *node = ptr->data_as<bNode>();
1815
1816 if (node->typeinfo->rna_ext.srna) {
1817 return node->typeinfo->rna_ext.srna;
1818 }
1819 else {
1820 return ptr->type;
1821 }
1822}
1823
1824static std::optional<std::string> rna_Node_path(const PointerRNA *ptr)
1825{
1826 const bNode *node = ptr->data_as<bNode>();
1827 char name_esc[sizeof(node->name) * 2];
1828
1829 BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1830 return fmt::format("nodes[\"{}\"]", name_esc);
1831}
1832
1833std::optional<std::string> rna_Node_ImageUser_path(const PointerRNA *ptr)
1834{
1835 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
1836 if (!ELEM(ntree->type, NTREE_SHADER, NTREE_CUSTOM)) {
1837 return std::nullopt;
1838 }
1839
1840 for (bNode *node = ntree->nodes.first(); node; node = node->next) {
1841 switch (node->type_legacy) {
1843 NodeTexEnvironment *data = static_cast<NodeTexEnvironment *>(node->storage);
1844 if (&data->iuser != ptr->data) {
1845 continue;
1846 }
1847 break;
1848 }
1849 case SH_NODE_TEX_IMAGE: {
1850 NodeTexImage *data = static_cast<NodeTexImage *>(node->storage);
1851 if (&data->iuser != ptr->data) {
1852 continue;
1853 }
1854 break;
1855 }
1856 default:
1857 continue;
1858 }
1859
1860 char name_esc[sizeof(node->name) * 2];
1861 BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1862 return fmt::format("nodes[\"{}\"].image_user", name_esc);
1863 }
1864
1865 return std::nullopt;
1866}
1867
1868static bool rna_Node_poll(const bke::bNodeType *ntype,
1869 const bNodeTree *ntree,
1870 const char ** /*r_disabled_hint*/)
1871{
1873 FunctionRNA *func;
1874 void *ret;
1875 bool visible;
1876
1877 PointerRNA ptr = RNA_pointer_create_discrete(nullptr, ntype->rna_ext.srna, nullptr); /* dummy */
1878 func = rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1879
1880 RNA_parameter_list_create(&list, &ptr, func);
1881 RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1882 ntype->rna_ext.call(nullptr, &ptr, func, &list);
1883
1884 RNA_parameter_get_lookup(&list, "visible", &ret);
1885 visible = *static_cast<bool *>(ret);
1886
1888
1889 return visible;
1890}
1891
1892static bool rna_Node_poll_instance(const bNode *node,
1893 const bNodeTree *ntree,
1894 const char ** /*disabled_info*/)
1895{
1897 FunctionRNA *func;
1898 void *ret;
1899 bool visible;
1900
1902 nullptr, node->typeinfo->rna_ext.srna, const_cast<bNode *>(node)); /* dummy */
1903 func = rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1904
1905 RNA_parameter_list_create(&list, &ptr, func);
1906 RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1907 node->typeinfo->rna_ext.call(nullptr, &ptr, func, &list);
1908
1909 RNA_parameter_get_lookup(&list, "visible", &ret);
1910 visible = *static_cast<bool *>(ret);
1911
1913
1914 return visible;
1915}
1916
1917static bool rna_Node_poll_instance_default(const bNode *node,
1918 const bNodeTree *ntree,
1919 const char **disabled_info)
1920{
1921 /* use the basic poll function */
1922 return rna_Node_poll(node->typeinfo, ntree, disabled_info);
1923}
1924
1925static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1926{
1928 FunctionRNA *func;
1929
1931 reinterpret_cast<ID *>(ntree), node->typeinfo->rna_ext.srna, node);
1932 func = rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1933
1934 RNA_parameter_list_create(&list, &ptr, func);
1935 node->typeinfo->rna_ext.call(nullptr, &ptr, func, &list);
1936
1938}
1939
1940static bool rna_Node_insert_link(bke::NodeInsertLinkParams &params)
1941{
1943 FunctionRNA *func;
1944
1946 reinterpret_cast<ID *>(&params.ntree), params.node.typeinfo->rna_ext.srna, &params.node);
1947 func = rna_Node_insert_link_func;
1948
1949 RNA_parameter_list_create(&list, &ptr, func);
1950 bNodeLink *link = &params.link;
1951 RNA_parameter_set_lookup(&list, "link", &link);
1952 params.node.typeinfo->rna_ext.call(nullptr, &ptr, func, &list);
1953
1955 return true;
1956}
1957
1958static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1959{
1960 bNode *node = ptr->data_as<bNode>();
1962 FunctionRNA *func;
1963
1964 func = rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1965
1966 RNA_parameter_list_create(&list, ptr, func);
1967 node->typeinfo->rna_ext.call(const_cast<bContext *>(C), ptr, func, &list);
1968
1970}
1971
1972static void rna_Node_copy(PointerRNA *ptr, const bNode *copynode)
1973{
1974 bNode *node = ptr->data_as<bNode>();
1976 FunctionRNA *func;
1977
1978 func = rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1979
1980 RNA_parameter_list_create(&list, ptr, func);
1981 RNA_parameter_set_lookup(&list, "node", &copynode);
1982 node->typeinfo->rna_ext.call(nullptr, ptr, func, &list);
1983
1985}
1986
1987static void rna_Node_free(PointerRNA *ptr)
1988{
1989 bNode *node = ptr->data_as<bNode>();
1991 FunctionRNA *func;
1992
1993 func = rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1994
1995 RNA_parameter_list_create(&list, ptr, func);
1996 node->typeinfo->rna_ext.call(nullptr, ptr, func, &list);
1997
1999}
2000
2001static void rna_Node_draw_buttons(ui::Layout &layout, bContext *C, PointerRNA *ptr)
2002{
2003 bNode *node = ptr->data_as<bNode>();
2005 FunctionRNA *func;
2006
2007 func = rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
2008
2009 RNA_parameter_list_create(&list, ptr, func);
2010 RNA_parameter_set_lookup(&list, "context", &C);
2011 ui::Layout *layout_ptr = &layout;
2012 RNA_parameter_set_lookup(&list, "layout", &layout_ptr);
2013 node->typeinfo->rna_ext.call(C, ptr, func, &list);
2014
2016}
2017
2018static void rna_Node_draw_buttons_ext(ui::Layout &layout, bContext *C, PointerRNA *ptr)
2019{
2020 bNode *node = ptr->data_as<bNode>();
2022 FunctionRNA *func;
2023
2024 func = rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
2025
2026 RNA_parameter_list_create(&list, ptr, func);
2027 RNA_parameter_set_lookup(&list, "context", &C);
2028 ui::Layout *layout_ptr = &layout;
2029 RNA_parameter_set_lookup(&list, "layout", &layout_ptr);
2030 node->typeinfo->rna_ext.call(C, ptr, func, &list);
2031
2033}
2034
2035static void rna_Node_draw_label(const bNodeTree *ntree,
2036 const bNode *node,
2037 char *label,
2038 int label_maxncpy)
2039{
2041 FunctionRNA *func;
2042 void *ret;
2043 char *rlabel;
2044
2045 func = rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
2046
2048 const_cast<ID *>(&ntree->id), RNA_Node, const_cast<bNode *>(node));
2049 RNA_parameter_list_create(&list, &ptr, func);
2050 node->typeinfo->rna_ext.call(nullptr, &ptr, func, &list);
2051
2052 RNA_parameter_get_lookup(&list, "label", &ret);
2053 rlabel = static_cast<char *>(ret);
2054 BLI_strncpy(label, rlabel != nullptr ? rlabel : "", label_maxncpy);
2055
2057}
2058
2059static bool rna_Node_is_registered_node_type(StructRNA *type)
2060{
2061 return (RNA_struct_blender_type_get(type) != nullptr);
2062}
2063
2064static bool rna_Node_is_builtin(bke::bNodeType *nt)
2065{
2066 BLI_assert(nt);
2067
2068 /* `nt->rna_ext.data` is the python object. If it's nullptr then it's a
2069 * builtin node. */
2070 return nt->rna_ext.data == nullptr;
2071}
2072
2073static void rna_Node_is_registered_node_type_runtime(bContext * /*C*/,
2074 ReportList * /*reports*/,
2075 PointerRNA *ptr,
2076 ParameterList *parms)
2077{
2078 int result = (RNA_struct_blender_type_get(ptr->type) != nullptr);
2079 RNA_parameter_set_lookup(parms, "result", &result);
2080}
2081
2082static bool rna_Node_unregister(Main *bmain, StructRNA *type)
2083{
2084 bke::bNodeType *nt = static_cast<bke::bNodeType *>(RNA_struct_blender_type_get(type));
2085
2086 if (!nt || rna_Node_is_builtin(nt)) {
2087 return false;
2088 }
2090
2091 RNA_struct_free_extension(type, &nt->rna_ext);
2093
2094 /* this also frees the allocated nt pointer, no MEM_free call needed! */
2096
2097 /* update while blender is running */
2100 return true;
2101}
2102
2103/* Generic internal registration function.
2104 * Can be used to implement callbacks for registerable RNA node sub-types.
2105 */
2106static bke::bNodeType *rna_Node_register_base(Main *bmain,
2107 ReportList *reports,
2108 StructRNA *basetype,
2109 void *data,
2110 const char *identifier,
2111 StructValidateFunc validate,
2112 StructCallbackFunc call,
2114{
2115 bke::bNodeType *nt;
2116 bNode dummy_node = {};
2117 FunctionRNA *func;
2118 PropertyRNA *parm;
2119 bool have_function[10];
2120
2121 /* setup dummy node & node type to store static properties in */
2122 bke::bNodeType dummy_nt = {};
2123 /* this does some additional initialization of default values */
2124 bke::node_type_base_custom(dummy_nt, identifier, "", "CUSTOM", 0);
2125
2126 dummy_node.typeinfo = &dummy_nt;
2127 PointerRNA dummy_node_ptr = RNA_pointer_create_discrete(nullptr, basetype, &dummy_node);
2128
2129 /* validate the python class */
2130 if (validate(&dummy_node_ptr, data, have_function) != 0) {
2131 return nullptr;
2132 }
2133
2134 if (strlen(identifier) >= sizeof(dummy_node.idname)) {
2135 BKE_reportf(reports,
2136 RPT_ERROR,
2137 "Registering node class: '%s' is too long, maximum length is %d",
2138 identifier,
2139 int(sizeof(dummy_node.idname)));
2140 return nullptr;
2141 }
2142
2143 /* check if we have registered this node type before, and remove it */
2144 nt = bke::node_type_find(dummy_nt.idname);
2145 if (nt) {
2146 /* If it's an internal node, we cannot proceed. */
2147 if (rna_Node_is_builtin(nt)) {
2148 BKE_reportf(reports,
2149 RPT_ERROR,
2150 "Registering node class: '%s', bl_idname '%s' is a builtin node",
2151 identifier,
2152 dummy_nt.idname.c_str());
2153 return nullptr;
2154 }
2155
2156 BKE_reportf(reports,
2157 RPT_INFO,
2158 "Registering node class: '%s', bl_idname '%s' has been registered before, "
2159 "unregistering previous",
2160 identifier,
2161 dummy_nt.idname.c_str());
2162
2163 /* NOTE: unlike most types `nt->rna_ext.srna` doesn't need to be checked for nullptr. */
2164 if (!rna_Node_unregister(bmain, nt->rna_ext.srna)) {
2165 BKE_reportf(reports,
2166 RPT_ERROR,
2167 "Registering node class: '%s', bl_idname '%s' could not be unregistered",
2168 identifier,
2169 dummy_nt.idname.c_str());
2170 return nullptr;
2171 }
2172 }
2173
2174 /* create a new node type */
2175 nt = MEM_new<bke::bNodeType>(__func__, dummy_nt);
2176 nt->free_self = [](bke::bNodeType *type) { MEM_delete(type); };
2177
2178 nt->rna_ext.srna = RNA_def_struct_ptr(&RNA_blender_rna_get(), nt->idname.c_str(), basetype);
2179 nt->rna_ext.data = data;
2180 nt->rna_ext.call = call;
2181 nt->rna_ext.free = free;
2182 RNA_struct_blender_type_set(nt->rna_ext.srna, nt);
2183
2184 RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name.c_str(), nt->ui_description.c_str());
2185 RNA_def_struct_ui_icon(nt->rna_ext.srna, nt->ui_icon);
2186
2188 nt->rna_ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
2189 RNA_def_function_ui_description(func, "True if a registered node type");
2191 parm = RNA_def_boolean(func, "result", false, "Result", "");
2192 RNA_def_function_return(func, parm);
2193
2194 /* XXX bad level call! needed to initialize the basic draw functions ... */
2196
2197 nt->poll = (have_function[0]) ? rna_Node_poll : nullptr;
2198 nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
2199 nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : nullptr;
2200 nt->insert_link = (have_function[3]) ? rna_Node_insert_link : nullptr;
2201 nt->initfunc_api = (have_function[4]) ? rna_Node_init : nullptr;
2202 nt->copyfunc_api = (have_function[5]) ? rna_Node_copy : nullptr;
2203 nt->freefunc_api = (have_function[6]) ? rna_Node_free : nullptr;
2204 nt->draw_buttons = (have_function[7]) ? rna_Node_draw_buttons : nullptr;
2205 nt->draw_buttons_ex = (have_function[8]) ? rna_Node_draw_buttons_ext : nullptr;
2206 nt->labelfunc = (have_function[9]) ? rna_Node_draw_label : nullptr;
2207
2208 /* sanitize size values in case not all have been registered */
2209 if (nt->maxwidth < nt->minwidth) {
2210 nt->maxwidth = nt->minwidth;
2211 }
2212 if (nt->maxheight < nt->minheight) {
2213 nt->maxheight = nt->minheight;
2214 }
2215 CLAMP(nt->default_width, nt->minwidth, nt->maxwidth);
2216 CLAMP(nt->height, nt->minheight, nt->maxheight);
2217
2218 return nt;
2219}
2220
2221static StructRNA *rna_Node_register(Main *bmain,
2222 ReportList *reports,
2223 void *data,
2224 const char *identifier,
2225 StructValidateFunc validate,
2226 StructCallbackFunc call,
2228{
2229 bke::bNodeType *nt = rna_Node_register_base(
2230 bmain, reports, RNA_Node, data, identifier, validate, call, free);
2231 if (!nt) {
2232 return nullptr;
2233 }
2234
2236
2237 /* update while blender is running */
2240 return nt->rna_ext.srna;
2241}
2242
2243static bool compositor_node_asset_trait_flag_get(PointerRNA *ptr,
2245{
2246 const bNodeTree *ntree = ptr->data_as<bNodeTree>();
2247 if (!ntree->compositor_node_asset_traits) {
2248 return false;
2249 }
2250 return ntree->compositor_node_asset_traits->flag & flag;
2251}
2252static bool rna_CompositorNodeTree_is_strip_modifier_get(PointerRNA *ptr)
2253{
2254 return compositor_node_asset_trait_flag_get(ptr, COMPOSIT_NODE_ASSET_STRIP_MODIFIER);
2255}
2256static void compositor_node_asset_trait_flag_set(PointerRNA *ptr,
2258 const bool value)
2259{
2260 bNodeTree *ntree = ptr->data_as<bNodeTree>();
2261 if (!ntree->compositor_node_asset_traits) {
2262 ntree->compositor_node_asset_traits = MEM_new<CompositorNodeAssetTraits>(__func__);
2263 }
2264 SET_FLAG_FROM_TEST(ntree->compositor_node_asset_traits->flag, value, flag);
2265}
2266static void rna_CompositorNodeTree_is_strip_modifier_set(PointerRNA *ptr, bool value)
2267{
2268 compositor_node_asset_trait_flag_set(ptr, COMPOSIT_NODE_ASSET_STRIP_MODIFIER, value);
2269}
2270
2271static bool rna_CompositorNodeTree_allow_usage_in_scene_compositor_effect_get(PointerRNA *ptr)
2272{
2273 return compositor_node_asset_trait_flag_get(ptr, COMPOSIT_NODE_ASSET_SCENE_EFFECT);
2274}
2275
2276static void rna_CompositorNodeTree_allow_usage_in_scene_compositor_effect_set(PointerRNA *ptr,
2277 bool value)
2278{
2279 compositor_node_asset_trait_flag_set(ptr, COMPOSIT_NODE_ASSET_SCENE_EFFECT, value);
2280}
2281
2282static const EnumPropertyItem *itemf_function_check(
2283 const EnumPropertyItem *original_item_array,
2284 FunctionRef<bool(const EnumPropertyItem *item)> value_supported)
2285{
2286 EnumPropertyItem *item_array = nullptr;
2287 int items_len = 0;
2288
2289 for (const EnumPropertyItem *item = original_item_array; item->identifier != nullptr; item++) {
2290 if (value_supported(item)) {
2291 RNA_enum_item_add(&item_array, &items_len, item);
2292 }
2293 }
2294
2295 RNA_enum_item_end(&item_array, &items_len);
2296 return item_array;
2297}
2298
2299static bool geometry_node_asset_trait_flag_get(PointerRNA *ptr,
2300 const GeometryNodeAssetTraitFlag flag)
2301{
2302 const bNodeTree *ntree = ptr->data_as<bNodeTree>();
2303 if (!ntree->geometry_node_asset_traits) {
2304 return false;
2305 }
2306 return ntree->geometry_node_asset_traits->flag & flag;
2307}
2308
2309static void rna_GeometryNodeTree_node_tool_idname_get(PointerRNA *ptr, char *value)
2310{
2311 bNodeTree *ntree = ptr->data_as<bNodeTree>();
2312 if (!ntree->geometry_node_asset_traits) {
2313 value[0] = '\0';
2314 return;
2315 }
2316 const char *idname = ntree->geometry_node_asset_traits->node_tool_idname;
2317 strcpy(value, idname ? idname : "");
2318}
2319
2320static int rna_GeometryNodeTree_node_tool_idname_length(PointerRNA *ptr)
2321{
2322 bNodeTree *ntree = ptr->data_as<bNodeTree>();
2323 if (!ntree->geometry_node_asset_traits) {
2324 return 0;
2325 }
2326 const char *idname = ntree->geometry_node_asset_traits->node_tool_idname;
2327 return idname ? strlen(idname) : 0;
2328}
2329
2330static void rna_GeometryNodeTree_node_tool_idname_set(PointerRNA *ptr, const char *value)
2331{
2332 bNodeTree *ntree = ptr->data_as<bNodeTree>();
2333 if (!ntree->geometry_node_asset_traits) {
2334 ntree->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__);
2335 }
2336 if (ntree->geometry_node_asset_traits->node_tool_idname) {
2337 MEM_delete(ntree->geometry_node_asset_traits->node_tool_idname);
2338 }
2339 if (value && value[0]) {
2340 ntree->geometry_node_asset_traits->node_tool_idname = BLI_strdup(value);
2341 }
2342 else {
2343 ntree->geometry_node_asset_traits->node_tool_idname = nullptr;
2344 }
2345}
2346
2347static void geometry_node_asset_trait_flag_set(PointerRNA *ptr,
2348 const GeometryNodeAssetTraitFlag flag,
2349 const bool value)
2350{
2351 bNodeTree *ntree = ptr->data_as<bNodeTree>();
2352 if (!ntree->geometry_node_asset_traits) {
2353 ntree->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__);
2354 }
2355 SET_FLAG_FROM_TEST(ntree->geometry_node_asset_traits->flag, value, flag);
2356}
2357
2358static bool rna_GeometryNodeTree_is_tool_get(PointerRNA *ptr)
2359{
2360 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_TOOL);
2361}
2362static void rna_GeometryNodeTree_is_tool_set(PointerRNA *ptr, bool value)
2363{
2364 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_TOOL, value);
2365}
2366
2367static bool rna_GeometryNodeTree_is_modifier_get(PointerRNA *ptr)
2368{
2369 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_MODIFIER);
2370}
2371static void rna_GeometryNodeTree_is_modifier_set(PointerRNA *ptr, bool value)
2372{
2373 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_MODIFIER, value);
2374}
2375
2376static bool rna_GeometryNodeTree_is_mode_object_get(PointerRNA *ptr)
2377{
2378 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_OBJECT);
2379}
2380static void rna_GeometryNodeTree_is_mode_object_set(PointerRNA *ptr, bool value)
2381{
2382 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_OBJECT, value);
2383}
2384
2385static bool rna_GeometryNodeTree_is_mode_edit_get(PointerRNA *ptr)
2386{
2387 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_EDIT);
2388}
2389static void rna_GeometryNodeTree_is_mode_edit_set(PointerRNA *ptr, bool value)
2390{
2391 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_EDIT, value);
2392}
2393
2394static bool rna_GeometryNodeTree_is_mode_sculpt_get(PointerRNA *ptr)
2395{
2396 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_SCULPT);
2397}
2398static void rna_GeometryNodeTree_is_mode_sculpt_set(PointerRNA *ptr, bool value)
2399{
2400 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_SCULPT, value);
2401}
2402
2403static bool rna_GeometryNodeTree_is_mode_paint_get(PointerRNA *ptr)
2404{
2405 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_PAINT);
2406}
2407static void rna_GeometryNodeTree_is_mode_paint_set(PointerRNA *ptr, bool value)
2408{
2409 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_PAINT, value);
2410}
2411
2412static bool rna_GeometryNodeTree_is_type_mesh_get(PointerRNA *ptr)
2413{
2414 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_MESH);
2415}
2416static void rna_GeometryNodeTree_is_type_mesh_set(PointerRNA *ptr, bool value)
2417{
2418 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_MESH, value);
2419}
2420
2421static bool rna_GeometryNodeTree_is_type_curve_get(PointerRNA *ptr)
2422{
2423 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_CURVE);
2424}
2425static void rna_GeometryNodeTree_is_type_curve_set(PointerRNA *ptr, bool value)
2426{
2427 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_CURVE, value);
2428}
2429
2430static bool rna_GeometryNodeTree_is_type_pointcloud_get(PointerRNA *ptr)
2431{
2432 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_POINTCLOUD);
2433}
2434static void rna_GeometryNodeTree_is_type_pointcloud_set(PointerRNA *ptr, bool value)
2435{
2436 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_POINTCLOUD, value);
2437}
2438
2439static bool rna_GeometryNodeTree_use_wait_for_click_get(PointerRNA *ptr)
2440{
2441 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_WAIT_FOR_CURSOR);
2442}
2443static void rna_GeometryNodeTree_use_wait_for_click_set(PointerRNA *ptr, bool value)
2444{
2445 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_WAIT_FOR_CURSOR, value);
2446}
2447
2448static bool rna_GeometryNodeTree_is_type_grease_pencil_get(PointerRNA *ptr)
2449{
2450 return geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_GREASE_PENCIL);
2451}
2452static void rna_GeometryNodeTree_is_type_grease_pencil_set(PointerRNA *ptr, bool value)
2453{
2454 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_GREASE_PENCIL, value);
2455}
2456
2457static bool rna_GeometryNodeTree_modifier_manage_panel_get(PointerRNA *ptr)
2458{
2459 return !geometry_node_asset_trait_flag_get(ptr, GEO_NODE_ASSET_HIDE_MODIFIER_MANAGE_PANEL);
2460}
2461static void rna_GeometryNodeTree_modifier_manage_panel_set(PointerRNA *ptr, bool value)
2462{
2463 geometry_node_asset_trait_flag_set(ptr, GEO_NODE_ASSET_HIDE_MODIFIER_MANAGE_PANEL, !value);
2464}
2465
2466static bool random_value_type_supported(const EnumPropertyItem *item)
2467{
2469}
2470static const EnumPropertyItem *rna_FunctionNodeRandomValue_type_itemf(bContext * /*C*/,
2471 PointerRNA * /*ptr*/,
2472 PropertyRNA * /*prop*/,
2473 bool *r_free)
2474{
2475 *r_free = true;
2476 return itemf_function_check(rna_enum_attribute_type_items, random_value_type_supported);
2477}
2478
2480{
2481 return ELEM(item->value,
2491}
2492
2493static bool generic_attribute_type_supported_with_socket(const EnumPropertyItem *item)
2494{
2495 return generic_attribute_type_supported(item) &&
2496 !ELEM(item->value, CD_PROP_BYTE_COLOR, CD_PROP_FLOAT2);
2497}
2498
2499static const EnumPropertyItem *rna_GeometryNodeAttributeType_type_with_socket_itemf(
2500 bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free)
2501{
2502 *r_free = true;
2503 return itemf_function_check(rna_enum_attribute_type_items,
2504 generic_attribute_type_supported_with_socket);
2505}
2506
2507static const EnumPropertyItem *rna_GeometryNodeAttributeDomain_attribute_domain_itemf(
2508 bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free)
2509{
2510 EnumPropertyItem *item_array = nullptr;
2511 int items_len = 0;
2512
2513 for (const EnumPropertyItem *item = rna_enum_attribute_domain_items; item->identifier != nullptr;
2514 item++)
2515 {
2516 RNA_enum_item_add(&item_array, &items_len, item);
2517 }
2518 RNA_enum_item_end(&item_array, &items_len);
2519
2520 *r_free = true;
2521 return item_array;
2522}
2523
2524static StructRNA *rna_ShaderNode_register(Main *bmain,
2525 ReportList *reports,
2526 void *data,
2527 const char *identifier,
2528 StructValidateFunc validate,
2529 StructCallbackFunc call,
2531{
2532 bke::bNodeType *nt = rna_Node_register_base(
2533 bmain, reports, RNA_ShaderNode, data, identifier, validate, call, free);
2534 if (!nt) {
2535 return nullptr;
2536 }
2537
2539
2540 /* update while blender is running */
2542
2543 return nt->rna_ext.srna;
2544}
2545
2546static StructRNA *rna_CompositorNode_register(Main *bmain,
2547 ReportList *reports,
2548 void *data,
2549 const char *identifier,
2550 StructValidateFunc validate,
2551 StructCallbackFunc call,
2553{
2554 bke::bNodeType *nt = rna_Node_register_base(
2555 bmain, reports, RNA_CompositorNode, data, identifier, validate, call, free);
2556 if (!nt) {
2557 return nullptr;
2558 }
2559
2561
2562 /* update while blender is running */
2564
2565 return nt->rna_ext.srna;
2566}
2567
2568static StructRNA *rna_TextureNode_register(Main *bmain,
2569 ReportList *reports,
2570 void *data,
2571 const char *identifier,
2572 StructValidateFunc validate,
2573 StructCallbackFunc call,
2575{
2576 bke::bNodeType *nt = rna_Node_register_base(
2577 bmain, reports, RNA_TextureNode, data, identifier, validate, call, free);
2578 if (!nt) {
2579 return nullptr;
2580 }
2581
2583
2584 /* update while blender is running */
2586
2587 return nt->rna_ext.srna;
2588}
2589
2590static StructRNA *rna_GeometryNode_register(Main *bmain,
2591 ReportList *reports,
2592 void *data,
2593 const char *identifier,
2594 StructValidateFunc validate,
2595 StructCallbackFunc call,
2597{
2598 bke::bNodeType *nt = rna_Node_register_base(
2599 bmain, reports, RNA_GeometryNode, data, identifier, validate, call, free);
2600 if (!nt) {
2601 return nullptr;
2602 }
2603
2605
2606 /* update while blender is running */
2608
2609 return nt->rna_ext.srna;
2610}
2611
2612static StructRNA *rna_FunctionNode_register(Main *bmain,
2613 ReportList *reports,
2614 void *data,
2615 const char *identifier,
2616 StructValidateFunc validate,
2617 StructCallbackFunc call,
2619{
2620 bke::bNodeType *nt = rna_Node_register_base(
2621 bmain, reports, RNA_FunctionNode, data, identifier, validate, call, free);
2622 if (!nt) {
2623 return nullptr;
2624 }
2625
2627
2628 /* update while blender is running */
2630
2631 return nt->rna_ext.srna;
2632}
2633
2634static IDProperty **rna_Node_idprops(PointerRNA *ptr)
2635{
2636 bNode *node = ptr->data_as<bNode>();
2637 return &node->prop;
2638}
2639
2640static IDProperty **rna_Node_system_idprops(PointerRNA *ptr)
2641{
2642 bNode *node = ptr->data_as<bNode>();
2643 return &node->system_properties;
2644}
2645
2646static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value, ReportList * /*reports*/)
2647{
2648 bNode *node = ptr->data_as<bNode>();
2649 bNode *parent = value.data_as<bNode>();
2650 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
2651 const bNodeTree *parent_ntree = reinterpret_cast<bNodeTree *>(value.owner_id);
2652
2653 if (!parent) {
2654 bke::node_detach_node(*ntree, *node);
2655 return;
2656 }
2657
2658 /* XXX only Frame node allowed for now,
2659 * in the future should have a poll function or so to test possible attachment.
2660 */
2661 if (!parent->is_frame()) {
2662 return;
2663 }
2664
2665 if (bke::node_is_parent_and_child(*node, *parent)) {
2666 return;
2667 }
2668
2669 /* Only nodes from the same tree can be used as parents. */
2670 if (parent_ntree != ntree) {
2671 return;
2672 }
2673
2674 bke::node_detach_node(*ntree, *node);
2675 bke::node_attach_node(*ntree, *node, *parent);
2676}
2677
2678static void rna_Node_internal_links_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2679{
2680 bNode *node = ptr->data_as<bNode>();
2682 ptr,
2683 node->runtime->internal_links.data(),
2684 sizeof(bNodeInternalLink),
2685 node->runtime->internal_links.size(),
2686 false,
2687 nullptr);
2688}
2689
2690static PointerRNA rna_NodeInternalLink_from_socket_get(PointerRNA *ptr)
2691{
2692 bNodeInternalLink *link = static_cast<bNodeInternalLink *>(ptr->data);
2693 return RNA_pointer_create_id_subdata(*ptr->owner_id, RNA_NodeSocket, link->in);
2694}
2695
2696static PointerRNA rna_NodeInternalLink_to_socket_get(PointerRNA *ptr)
2697{
2698 bNodeInternalLink *link = static_cast<bNodeInternalLink *>(ptr->data);
2699 return RNA_pointer_create_id_subdata(*ptr->owner_id, RNA_NodeSocket, link->out);
2700}
2701
2706static bool allow_identifier_lookup(const bNode &node)
2707{
2708 switch (node.type_legacy) {
2709 case SH_NODE_MIX:
2710 case SH_NODE_MAP_RANGE:
2711 return false;
2712 default:
2713 return true;
2714 }
2715}
2716
2717static bNodeSocket *find_socket_by_key(bNode &node,
2718 const eNodeSocketInOut in_out,
2719 const StringRef key)
2720{
2721 ListBaseT<bNodeSocket> *sockets = in_out == SOCK_IN ? &node.inputs : &node.outputs;
2722 if (allow_identifier_lookup(node)) {
2723 for (bNodeSocket &socket : *sockets) {
2724 if (socket.is_available()) {
2725 if (socket.identifier == key) {
2726 return &socket;
2727 }
2728 }
2729 }
2730 }
2731 for (bNodeSocket &socket : *sockets) {
2732 if (socket.is_available()) {
2733 if (socket.name == key) {
2734 return &socket;
2735 }
2736 }
2737 }
2738 return nullptr;
2739}
2740
2741static bool rna_NodeInputs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
2742{
2743 bNode *node = ptr->data_as<bNode>();
2744 if (bNodeSocket *socket = find_socket_by_key(*node, SOCK_IN, key)) {
2745 rna_pointer_create_with_ancestors(*ptr, RNA_NodeSocket, socket, *r_ptr);
2746 return true;
2747 }
2748 return false;
2749}
2750
2751static bool rna_NodeOutputs_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
2752{
2753 bNode *node = ptr->data_as<bNode>();
2754 if (bNodeSocket *socket = find_socket_by_key(*node, SOCK_OUT, key)) {
2755 rna_pointer_create_with_ancestors(*ptr, RNA_NodeSocket, socket, *r_ptr);
2756 return true;
2757 }
2758 return false;
2759}
2760
2761static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
2762{
2763 bNode *node = ptr->data_as<bNode>();
2764 bNode *parent = static_cast<bNode *>(value.data);
2765
2766 /* XXX only Frame node allowed for now,
2767 * in the future should have a poll function or so to test possible attachment.
2768 */
2769 if (!parent->is_frame()) {
2770 return false;
2771 }
2772
2773 if (node->is_frame() && bke::node_is_parent_and_child(*node, *parent)) {
2774 return false;
2775 }
2776
2777 return true;
2778}
2779
2780void rna_Node_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
2781{
2782 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
2783 bNode *node = ptr->data_as<bNode>();
2785 BKE_main_ensure_invariants(*bmain, ntree->id);
2786}
2787
2788void rna_Node_update_relations(Main *bmain, Scene *scene, PointerRNA *ptr)
2789{
2790 rna_Node_update(bmain, scene, ptr);
2792}
2793
2794static void rna_Node_socket_value_update(ID *id, bNode * /*node*/, bContext *C)
2795{
2796 BKE_ntree_update_tag_all(reinterpret_cast<bNodeTree *>(id));
2798}
2799
2800static void rna_Node_select_set(PointerRNA *ptr, bool value)
2801{
2802 bNode *node = ptr->data_as<bNode>();
2804}
2805
2806static void rna_Node_mute_set(PointerRNA *ptr, bool value)
2807{
2808 bNode *node = ptr->data_as<bNode>();
2809 if (!node->typeinfo->no_muting) {
2810 SET_FLAG_FROM_TEST(node->flag, value, NODE_MUTED);
2811 }
2812}
2813
2814static void rna_Node_name_set(PointerRNA *ptr, const char *value)
2815{
2816 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
2817 bNode *node = ptr->data_as<bNode>();
2818 char oldname[sizeof(node->name)];
2819
2820 /* make a copy of the old name first */
2821 STRNCPY(oldname, node->name);
2822 /* set new name */
2823 STRNCPY_UTF8(node->name, value);
2824
2825 bke::node_unique_name(*ntree, *node);
2826
2827 /* fix all the animation data which may link to this */
2828 BKE_animdata_fix_paths(ntree->id,
2829 "nodes",
2830 RNA_path_name_to_infix(oldname),
2832 /*verify_paths=*/true,
2833 *G_MAIN);
2834}
2835
2836static int rna_Node_color_tag_get(PointerRNA *ptr)
2837{
2838 bNode *node = ptr->data_as<bNode>();
2839 return int(bke::node_color_tag(*node));
2840}
2841
2842static bool allow_adding_sockets(const bNode &node)
2843{
2844 return ELEM(node.type_legacy, NODE_CUSTOM, SH_NODE_SCRIPT);
2845}
2846
2847static bool allow_changing_sockets(bNode *node)
2848{
2850}
2851
2852static bNodeSocket *rna_Node_inputs_new(ID *id,
2853 bNode *node,
2854 Main *bmain,
2855 ReportList *reports,
2856 const char *type,
2857 const char *name,
2858 const char *identifier,
2859 const bool use_multi_input)
2860{
2861 if (!allow_adding_sockets(*node)) {
2862 BKE_report(reports, RPT_ERROR, "Cannot add socket to built-in node");
2863 return nullptr;
2864 }
2865 if (identifier == nullptr) {
2866 /* Use the name as default identifier if no separate identifier is provided. */
2867 identifier = name;
2868 }
2869
2870 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2871 bNodeSocket *sock = bke::node_add_socket(*ntree, *node, SOCK_IN, type, identifier, name);
2872
2873 if (sock == nullptr) {
2874 BKE_report(reports, RPT_ERROR, "Unable to create socket");
2875 }
2876 else {
2877 if (use_multi_input) {
2878 sock->flag |= SOCK_MULTI_INPUT;
2879 }
2880 BKE_main_ensure_invariants(*bmain, ntree->id);
2882 }
2883
2884 return sock;
2885}
2886
2887static bNodeSocket *rna_Node_outputs_new(ID *id,
2888 bNode *node,
2889 Main *bmain,
2890 ReportList *reports,
2891 const char *type,
2892 const char *name,
2893 const char *identifier,
2894 const bool use_multi_input)
2895{
2896 if (!allow_adding_sockets(*node)) {
2897 BKE_report(reports, RPT_ERROR, "Cannot add socket to built-in node");
2898 return nullptr;
2899 }
2900
2901 if (use_multi_input) {
2902 BKE_report(reports, RPT_ERROR, "Output sockets cannot be multi-input");
2903 return nullptr;
2904 }
2905
2906 if (identifier == nullptr) {
2907 /* Use the name as default identifier if no separate identifier is provided. */
2908 identifier = name;
2909 }
2910
2911 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2912 bNodeSocket *sock = bke::node_add_socket(*ntree, *node, SOCK_OUT, type, identifier, name);
2913
2914 if (sock == nullptr) {
2915 BKE_report(reports, RPT_ERROR, "Unable to create socket");
2916 }
2917 else {
2918 BKE_main_ensure_invariants(*bmain, ntree->id);
2920 }
2921
2922 return sock;
2923}
2924
2925static void rna_Node_socket_remove(
2926 ID *id, bNode *node, Main *bmain, ReportList *reports, bNodeSocket *sock)
2927{
2928 if (!allow_changing_sockets(node)) {
2929 BKE_report(reports, RPT_ERROR, "Unable to remove socket from built-in node");
2930 return;
2931 }
2932
2933 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2934
2935 if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
2936 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
2937 }
2938 else {
2939 bke::node_remove_socket(*ntree, *node, *sock);
2940
2941 BKE_main_ensure_invariants(*bmain, ntree->id);
2943 }
2944}
2945
2946static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain, ReportList *reports)
2947{
2948 if (!allow_changing_sockets(node)) {
2949 BKE_report(reports, RPT_ERROR, "Unable to remove sockets from built-in node");
2950 return;
2951 }
2952
2953 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2954 bNodeSocket *sock, *nextsock;
2955
2956 for (sock = node->inputs.first(); sock; sock = nextsock) {
2957 nextsock = sock->next;
2958 bke::node_remove_socket(*ntree, *node, *sock);
2959 }
2960
2961 BKE_main_ensure_invariants(*bmain, ntree->id);
2963}
2964
2965static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain, ReportList *reports)
2966{
2967 if (!allow_changing_sockets(node)) {
2968 BKE_report(reports, RPT_ERROR, "Unable to remove socket from built-in node");
2969 return;
2970 }
2971
2972 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2973 bNodeSocket *sock, *nextsock;
2974
2975 for (sock = node->outputs.first(); sock; sock = nextsock) {
2976 nextsock = sock->next;
2977 bke::node_remove_socket(*ntree, *node, *sock);
2978 }
2979
2980 BKE_main_ensure_invariants(*bmain, ntree->id);
2982}
2983
2984static void rna_Node_inputs_move(
2985 ID *id, bNode *node, Main *bmain, ReportList *reports, int from_index, int to_index)
2986{
2987 if (!allow_changing_sockets(node)) {
2988 BKE_report(reports, RPT_ERROR, "Unable to move sockets in built-in node");
2989 return;
2990 }
2991
2992 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2993 bNodeSocket *sock;
2994
2995 if (from_index == to_index) {
2996 return;
2997 }
2998 if (from_index < 0 || to_index < 0) {
2999 return;
3000 }
3001
3002 sock = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, from_index));
3003 if (to_index < from_index) {
3004 bNodeSocket *nextsock = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, to_index));
3005 if (nextsock) {
3006 BLI_remlink(&node->inputs, sock);
3007 BLI_insertlinkbefore(&node->inputs, nextsock, sock);
3008 }
3009 }
3010 else {
3011 bNodeSocket *prevsock = static_cast<bNodeSocket *>(BLI_findlink(&node->inputs, to_index));
3012 if (prevsock) {
3013 BLI_remlink(&node->inputs, sock);
3014 BLI_insertlinkafter(&node->inputs, prevsock, sock);
3015 }
3016 }
3017
3019 BKE_main_ensure_invariants(*bmain, ntree->id);
3021}
3022
3023static void rna_Node_outputs_move(
3024 ID *id, bNode *node, Main *bmain, ReportList *reports, int from_index, int to_index)
3025{
3026 if (!allow_changing_sockets(node)) {
3027 BKE_report(reports, RPT_ERROR, "Unable to move sockets in built-in node");
3028 return;
3029 }
3030
3031 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3032 bNodeSocket *sock;
3033
3034 if (from_index == to_index) {
3035 return;
3036 }
3037 if (from_index < 0 || to_index < 0) {
3038 return;
3039 }
3040
3041 sock = static_cast<bNodeSocket *>(BLI_findlink(&node->outputs, from_index));
3042 if (to_index < from_index) {
3043 bNodeSocket *nextsock = static_cast<bNodeSocket *>(BLI_findlink(&node->outputs, to_index));
3044 if (nextsock) {
3045 BLI_remlink(&node->outputs, sock);
3046 BLI_insertlinkbefore(&node->outputs, nextsock, sock);
3047 }
3048 }
3049 else {
3050 bNodeSocket *prevsock = static_cast<bNodeSocket *>(BLI_findlink(&node->outputs, to_index));
3051 if (prevsock) {
3052 BLI_remlink(&node->outputs, sock);
3053 BLI_insertlinkafter(&node->outputs, prevsock, sock);
3054 }
3055 }
3056
3058 BKE_main_ensure_invariants(*bmain, ntree->id);
3060}
3061
3062static void rna_Node_width_range(
3063 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3064{
3065 bNode *node = ptr->data_as<bNode>();
3066 *min = *softmin = node->typeinfo->minwidth;
3067 *max = *softmax = node->typeinfo->maxwidth;
3068}
3069
3070static void rna_Node_height_range(
3071 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3072{
3073 bNode *node = ptr->data_as<bNode>();
3074 *min = *softmin = node->typeinfo->minheight;
3075 *max = *softmax = node->typeinfo->maxheight;
3076}
3077
3078static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
3079{
3080 bNode *node = ptr->data_as<bNode>();
3081 const float2 dimensions = bke::node_dimensions_get(*node);
3082 value[0] = dimensions[0];
3083 value[1] = dimensions[1];
3084}
3085
3086/* ******** Node Types ******** */
3087
3088static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
3089{
3090 bke::bNodeSocketTemplate *stemp = static_cast<bke::bNodeSocketTemplate *>(ptr->data);
3091 strcpy(value, stemp->name);
3092}
3093
3094static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
3095{
3096 bke::bNodeSocketTemplate *stemp = static_cast<bke::bNodeSocketTemplate *>(ptr->data);
3097 return strlen(stemp->name);
3098}
3099
3100static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
3101{
3102 bke::bNodeSocketTemplate *stemp = static_cast<bke::bNodeSocketTemplate *>(ptr->data);
3103 strcpy(value, stemp->identifier);
3104}
3105
3106static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
3107{
3108 bke::bNodeSocketTemplate *stemp = static_cast<bke::bNodeSocketTemplate *>(ptr->data);
3109 return strlen(stemp->identifier);
3110}
3111
3112static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
3113{
3114 bke::bNodeSocketTemplate *stemp = static_cast<bke::bNodeSocketTemplate *>(ptr->data);
3115 return stemp->type;
3116}
3117
3118static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
3119{
3120 bke::bNodeType *ntype = static_cast<bke::bNodeType *>(RNA_struct_blender_type_get(srna));
3121 if (ntype && ntype->inputs) {
3122 bke::bNodeSocketTemplate *stemp = ntype->inputs;
3123 int i = 0;
3124 while (i < index && stemp->type >= 0) {
3125 i++;
3126 stemp++;
3127 }
3128 if (i == index && stemp->type >= 0) {
3129 PointerRNA ptr = RNA_pointer_create_discrete(nullptr, RNA_NodeInternalSocketTemplate, stemp);
3130 return ptr;
3131 }
3132 }
3133 return {};
3134}
3135
3136static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
3137{
3138 bke::bNodeType *ntype = static_cast<bke::bNodeType *>(RNA_struct_blender_type_get(srna));
3139 if (ntype && ntype->outputs) {
3140 bke::bNodeSocketTemplate *stemp = ntype->outputs;
3141 int i = 0;
3142 while (i < index && stemp->type >= 0) {
3143 i++;
3144 stemp++;
3145 }
3146 if (i == index && stemp->type >= 0) {
3147 PointerRNA ptr = RNA_pointer_create_discrete(nullptr, RNA_NodeInternalSocketTemplate, stemp);
3148 return ptr;
3149 }
3150 }
3151 return {};
3152}
3153
3154static bool rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
3155{
3156 bke::bNodeType *ntype = static_cast<bke::bNodeType *>(RNA_struct_blender_type_get(srna));
3157 const char *disabled_hint;
3158 return ntype && (!ntype->poll || ntype->poll(ntype, ntree, &disabled_hint));
3159}
3160
3161static bool rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
3162{
3163 bke::bNodeType *ntype = node->typeinfo;
3164 const char *disabled_hint;
3165 if (ntype->poll_instance) {
3166 return ntype->poll_instance(node, ntree, &disabled_hint);
3167 }
3168 else {
3169 /* fall back to basic poll function */
3170 return !ntype->poll || ntype->poll(ntype, ntree, &disabled_hint);
3171 }
3172}
3173
3174static void rna_NodeInternal_update(ID *id, bNode *node, Main *bmain)
3175{
3176 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3178 BKE_main_ensure_invariants(*bmain, ntree->id);
3179}
3180
3181static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, bContext *C, ui::Layout *layout)
3182{
3183 if (node->typeinfo->draw_buttons) {
3184 PointerRNA ptr = RNA_pointer_create_discrete(id, RNA_Node, node);
3185 node->typeinfo->draw_buttons(*layout, C, &ptr);
3186 }
3187}
3188
3189static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, bContext *C, ui::Layout *layout)
3190{
3191 if (node->typeinfo->draw_buttons_ex) {
3192 PointerRNA ptr = RNA_pointer_create_discrete(id, RNA_Node, node);
3193 node->typeinfo->draw_buttons_ex(*layout, C, &ptr);
3194 }
3195 else if (node->typeinfo->draw_buttons) {
3196 PointerRNA ptr = RNA_pointer_create_discrete(id, RNA_Node, node);
3197 node->typeinfo->draw_buttons(*layout, C, &ptr);
3198 }
3199}
3200
3201static StructRNA *rna_NodeCustomGroup_register(Main *bmain,
3202 ReportList *reports,
3203 void *data,
3204 const char *identifier,
3205 StructValidateFunc validate,
3206 StructCallbackFunc call,
3208{
3209 bke::bNodeType *nt = rna_Node_register_base(
3210 bmain, reports, RNA_NodeCustomGroup, data, identifier, validate, call, free);
3211 if (!nt) {
3212 return nullptr;
3213 }
3214
3216
3217 /* update while blender is running */
3219
3220 return nt->rna_ext.srna;
3221}
3222
3223static StructRNA *rna_GeometryNodeCustomGroup_register(Main *bmain,
3224 ReportList *reports,
3225 void *data,
3226 const char *identifier,
3227 StructValidateFunc validate,
3228 StructCallbackFunc call,
3230{
3231 bke::bNodeType *nt = rna_Node_register_base(
3232 bmain, reports, RNA_GeometryNodeCustomGroup, data, identifier, validate, call, free);
3233
3234 if (!nt) {
3235 return nullptr;
3236 }
3237
3238 nt->type_legacy = NODE_CUSTOM_GROUP;
3239 nt->ui_class = node_group_ui_class;
3240
3242
3244
3246
3247 return nt->rna_ext.srna;
3248}
3249
3251
3252static StructRNA *rna_ShaderNodeCustomGroup_register(Main *bmain,
3253 ReportList *reports,
3254 void *data,
3255 const char *identifier,
3256 StructValidateFunc validate,
3257 StructCallbackFunc call,
3259{
3260 bke::bNodeType *nt = rna_Node_register_base(
3261 bmain, reports, RNA_ShaderNodeCustomGroup, data, identifier, validate, call, free);
3262
3263 if (!nt) {
3264 return nullptr;
3265 }
3266
3267 nt->type_legacy = NODE_CUSTOM_GROUP;
3268 nt->ui_class = node_group_ui_class;
3269
3271
3273
3275
3276 return nt->rna_ext.srna;
3277}
3278
3279static StructRNA *rna_CompositorNodeCustomGroup_register(Main *bmain,
3280 ReportList *reports,
3281 void *data,
3282 const char *identifier,
3283 StructValidateFunc validate,
3284 StructCallbackFunc call,
3286{
3287 bke::bNodeType *nt = rna_Node_register_base(
3288 bmain, reports, RNA_CompositorNodeCustomGroup, data, identifier, validate, call, free);
3289 if (!nt) {
3290 return nullptr;
3291 }
3292
3293 nt->type_legacy = NODE_CUSTOM_GROUP;
3294 nt->ui_class = node_group_ui_class;
3295
3297
3299
3301
3302 return nt->rna_ext.srna;
3303}
3304
3305static void rna_Node_tex_image_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
3306{
3307 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
3308 bNode *node = ptr->data_as<bNode>();
3309
3311 BKE_main_ensure_invariants(*bmain, ntree->id);
3314}
3315
3316static void rna_NodeGroup_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
3317{
3318 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
3319 bNode *node = ptr->data_as<bNode>();
3320
3322 BKE_main_ensure_invariants(*bmain, ntree->id);
3324}
3325
3326static void rna_NodeGroup_node_tree_set(PointerRNA *ptr,
3327 const PointerRNA value,
3328 ReportList * /*reports*/)
3329{
3330 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
3331 bNode *node = ptr->data_as<bNode>();
3332 bNodeTree *ngroup = static_cast<bNodeTree *>(value.data);
3333
3334 const char *disabled_hint = nullptr;
3335 if (bke::node_group_poll(ntree, ngroup, &disabled_hint)) {
3336 if (node->id) {
3337 id_us_min(node->id);
3338 }
3339 if (ngroup) {
3340 id_us_plus(&ngroup->id);
3341 }
3342
3343 node->id = &ngroup->id;
3344 }
3345}
3346
3347static bool rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
3348{
3349 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
3350 bNodeTree *ngroup = static_cast<bNodeTree *>(value.data);
3351
3352 /* only allow node trees of the same type as the group node's tree */
3353 if (ngroup->type != ntree->type) {
3354 return false;
3355 }
3356
3357 const char *disabled_hint = nullptr;
3358 return bke::node_group_poll(ntree, ngroup, &disabled_hint);
3359}
3360
3361static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value, ReportList * /*reports*/)
3362{
3363 bNode *node = ptr->data_as<bNode>();
3364
3365 if (node->id) {
3366 id_us_min(node->id);
3367 node->id = nullptr;
3368 }
3369
3370 node->id = static_cast<ID *>(value.data);
3371
3372 id_us_plus(node->id);
3373}
3374
3375static void rna_Node_image_layer_view_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3376{
3377 bNode *node = ptr->data_as<bNode>();
3378 Image *ima = reinterpret_cast<Image *>(node->id);
3379 ImageUser *iuser = static_cast<ImageUser *>(node->storage);
3380
3381 if (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
3383 {
3384 return;
3385 }
3386
3387 BKE_image_multilayer_index(ima->rr, iuser);
3388 BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_SRC_CHANGE);
3389
3390 rna_Node_update(bmain, scene, ptr);
3391}
3392
3393static const EnumPropertyItem *rna_ShaderNodeMix_data_type_itemf(bContext * /*C*/,
3394 PointerRNA *ptr,
3395 PropertyRNA * /*prop*/,
3396 bool *r_free)
3397{
3398 *r_free = true;
3399
3400 const auto rotation_supported_mix = [&](const EnumPropertyItem *item) -> bool {
3401 const eNodeSocketDatatype data_type = eNodeSocketDatatype(item->value);
3402 if (data_type == SOCK_ROTATION) {
3403 const bNodeTree *tree = reinterpret_cast<const bNodeTree *>(ptr->owner_id);
3404 if (ELEM(tree->type, NTREE_GEOMETRY, NTREE_COMPOSIT)) {
3405 return true;
3406 }
3407 }
3408 return ELEM(data_type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA);
3409 };
3410
3411 return itemf_function_check(rna_enum_mix_data_type_items, rotation_supported_mix);
3412}
3413
3414static const EnumPropertyItem *rna_Node_image_layer_itemf(bContext * /*C*/,
3415 PointerRNA *ptr,
3416 PropertyRNA * /*prop*/,
3417 bool *r_free)
3418{
3419 bNode *node = ptr->data_as<bNode>();
3420 Image *ima = reinterpret_cast<Image *>(node->id);
3421 const EnumPropertyItem *item = nullptr;
3422
3423 if (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
3425 {
3427 }
3428
3429 if (ima == nullptr || ima->rr == nullptr) {
3430 *r_free = false;
3432 }
3433
3434 const auto &item_from_render_layer = [&](const RenderLayer &rl,
3435 const int index) -> EnumPropertyItem {
3436 EnumPropertyItem tmp = {0};
3437 tmp.identifier = rl.name;
3438 /* Little trick: using space char instead empty string
3439 * makes the item selectable in the drop-down. */
3440 if (rl.name[0] == '\0') {
3441 tmp.name = " ";
3442 }
3443 else {
3444 tmp.name = rl.name;
3445 }
3446 tmp.value = index;
3447 return tmp;
3448 };
3449 item = rna_enum_property_items_from_listbase(ima->rr->layers, item_from_render_layer);
3450
3451 *r_free = true;
3452
3453 return item;
3454}
3455
3456static bool rna_Node_image_has_layers_get(PointerRNA *ptr)
3457{
3458 bNode *node = ptr->data_as<bNode>();
3459 Image *ima = reinterpret_cast<Image *>(node->id);
3460
3461 if (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
3463 {
3464 return false;
3465 }
3466
3467 if (!ima || !(ima->rr)) {
3468 return false;
3469 }
3470
3471 return RE_layers_have_name(ima->rr);
3472}
3473
3474static bool rna_Node_image_has_views_get(PointerRNA *ptr)
3475{
3476 bNode *node = ptr->data_as<bNode>();
3477 Image *ima = reinterpret_cast<Image *>(node->id);
3478
3479 if (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
3481 {
3482 return false;
3483 }
3484
3485 if (!ima || !(ima->rr)) {
3486 return false;
3487 }
3488
3489 return BLI_listbase_count_at_most(&ima->rr->views, 2) > 1;
3490}
3491
3492static const EnumPropertyItem *renderresult_views_add_enum(RenderView *rv)
3493{
3494 EnumPropertyItem *item = nullptr;
3495 EnumPropertyItem tmp = {0, "ALL", 0, "All", ""};
3496 int i = 1, totitem = 0;
3497
3498 /* option to use all views */
3499 RNA_enum_item_add(&item, &totitem, &tmp);
3500
3501 while (rv) {
3502 tmp.identifier = rv->name;
3503 /* Little trick: using space char instead empty string
3504 * makes the item selectable in the drop-down. */
3505 if (rv->name[0] == '\0') {
3506 tmp.name = " ";
3507 }
3508 else {
3509 tmp.name = rv->name;
3510 }
3511 tmp.value = i++;
3512 RNA_enum_item_add(&item, &totitem, &tmp);
3513 rv = rv->next;
3514 }
3515
3516 RNA_enum_item_end(&item, &totitem);
3517
3518 return item;
3519}
3520
3521static const EnumPropertyItem *rna_Node_image_view_itemf(bContext * /*C*/,
3522 PointerRNA *ptr,
3523 PropertyRNA * /*prop*/,
3524 bool *r_free)
3525{
3526 bNode *node = ptr->data_as<bNode>();
3527 Image *ima = reinterpret_cast<Image *>(node->id);
3528 const EnumPropertyItem *item = nullptr;
3529 RenderView *rv;
3530
3531 if (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
3533 {
3535 }
3536
3537 if (ima == nullptr || ima->rr == nullptr) {
3538 *r_free = false;
3540 }
3541
3542 rv = ima->rr->views.first();
3543 item = renderresult_views_add_enum(rv);
3544
3545 *r_free = true;
3546
3547 return item;
3548}
3549
3550static const EnumPropertyItem *rna_Node_view_layer_itemf(bContext * /*C*/,
3551 PointerRNA *ptr,
3552 PropertyRNA * /*prop*/,
3553 bool *r_free)
3554{
3555 bNode *node = ptr->data_as<bNode>();
3556 Scene *sce = reinterpret_cast<Scene *>(node->id);
3557 const EnumPropertyItem *item = nullptr;
3558
3559 if (sce == nullptr) {
3560 *r_free = false;
3562 }
3563
3564 const auto &item_from_view_layer = [&](const ViewLayer &vl,
3565 const int index) -> EnumPropertyItem {
3566 EnumPropertyItem tmp = {0};
3567 tmp.identifier = vl.name;
3568 /* Little trick: using space char instead empty string
3569 * makes the item selectable in the drop-down. */
3570 if (vl.name[0] == '\0') {
3571 tmp.name = " ";
3572 }
3573 else {
3574 tmp.name = vl.name;
3575 }
3576 tmp.value = index;
3577 return tmp;
3578 };
3579 item = rna_enum_property_items_from_listbase(sce->view_layers, item_from_view_layer);
3580
3581 *r_free = true;
3582
3583 return item;
3584}
3585
3586static void rna_Image_Node_update_id(Main *bmain, Scene *scene, PointerRNA *ptr)
3587{
3588 bNode *node = ptr->data_as<bNode>();
3589
3591 rna_Node_update_relations(bmain, scene, ptr);
3592}
3593
3594/* --------------------------------------------------------------------
3595 * White Balance Node.
3596 */
3597
3598static void rna_NodeColorBalance_input_whitepoint_get(PointerRNA *ptr, float value[3])
3599{
3600 bNode *node = ptr->data_as<bNode>();
3601 bNodeSocket *temperature_input = bke::node_find_socket(*node, SOCK_IN, "Input Temperature"_ustr);
3602 bNodeSocket *tint_input = bke::node_find_socket(*node, SOCK_IN, "Input Tint"_ustr);
3604 temperature_input->default_value_typed<bNodeSocketValueFloat>()->value,
3605 tint_input->default_value_typed<bNodeSocketValueFloat>()->value,
3606 value);
3607}
3608
3609static void rna_NodeColorBalance_input_whitepoint_set(PointerRNA *ptr, const float value[3])
3610{
3611 bNode *node = ptr->data_as<bNode>();
3612 bNodeSocket *temperature_input = bke::node_find_socket(*node, SOCK_IN, "Input Temperature"_ustr);
3613 bNodeSocket *tint_input = bke::node_find_socket(*node, SOCK_IN, "Input Tint"_ustr);
3615 value,
3616 temperature_input->default_value_typed<bNodeSocketValueFloat>()->value,
3617 tint_input->default_value_typed<bNodeSocketValueFloat>()->value);
3618}
3619
3620static void rna_NodeColorBalance_output_whitepoint_get(PointerRNA *ptr, float value[3])
3621{
3622 bNode *node = ptr->data_as<bNode>();
3623 bNodeSocket *temperature_input = bke::node_find_socket(
3624 *node, SOCK_IN, "Output Temperature"_ustr);
3625 bNodeSocket *tint_input = bke::node_find_socket(*node, SOCK_IN, "Output Tint"_ustr);
3627 temperature_input->default_value_typed<bNodeSocketValueFloat>()->value,
3628 tint_input->default_value_typed<bNodeSocketValueFloat>()->value,
3629 value);
3630}
3631
3632static void rna_NodeColorBalance_output_whitepoint_set(PointerRNA *ptr, const float value[3])
3633{
3634 bNode *node = ptr->data_as<bNode>();
3635 bNodeSocket *temperature_input = bke::node_find_socket(
3636 *node, SOCK_IN, "Output Temperature"_ustr);
3637 bNodeSocket *tint_input = bke::node_find_socket(*node, SOCK_IN, "Output Tint"_ustr);
3639 value,
3640 temperature_input->default_value_typed<bNodeSocketValueFloat>()->value,
3641 tint_input->default_value_typed<bNodeSocketValueFloat>()->value);
3642}
3643
3644static void rna_NodeCryptomatte_source_set(PointerRNA *ptr, int value)
3645{
3646 bNode *node = ptr->data_as<bNode>();
3647 if (node->id && node->custom1 != value) {
3648 id_us_min(node->id);
3649 node->id = nullptr;
3650 }
3651 node->custom1 = value;
3652}
3653
3654static int rna_NodeCryptomatte_layer_name_get(PointerRNA *ptr)
3655{
3656
3657 bNode *node = ptr->data_as<bNode>();
3658 NodeCryptomatte *storage = static_cast<NodeCryptomatte *>(node->storage);
3659 for (const auto [index, layer] : storage->runtime.layers.enumerate()) {
3660 if (STREQLEN(storage->layer_name, layer.name, sizeof(storage->layer_name))) {
3661 return index;
3662 }
3663 }
3664 return 0;
3665}
3666
3667static void rna_NodeCryptomatte_layer_name_set(PointerRNA *ptr, int new_value)
3668{
3669 bNode *node = ptr->data_as<bNode>();
3670 NodeCryptomatte *storage = static_cast<NodeCryptomatte *>(node->storage);
3671
3672 CryptomatteLayer *layer = static_cast<CryptomatteLayer *>(
3673 BLI_findlink(&storage->runtime.layers, new_value));
3674 if (layer) {
3675 STRNCPY(storage->layer_name, layer->name);
3676 }
3677}
3678
3679static const EnumPropertyItem *rna_NodeCryptomatte_layer_name_itemf(bContext * /*C*/,
3680 PointerRNA *ptr,
3681 PropertyRNA * /*prop*/,
3682 bool *r_free)
3683{
3684 bNode *node = ptr->data_as<bNode>();
3685 NodeCryptomatte *storage = static_cast<NodeCryptomatte *>(node->storage);
3686 EnumPropertyItem *item = nullptr;
3687 EnumPropertyItem temp = {0, "", 0, "", ""};
3688 int totitem = 0;
3689
3690 for (const auto [layer_index, layer] : storage->runtime.layers.enumerate()) {
3691 temp.value = layer_index;
3692 temp.identifier = layer.name;
3693 temp.name = layer.name;
3694 RNA_enum_item_add(&item, &totitem, &temp);
3695 }
3696
3697 RNA_enum_item_end(&item, &totitem);
3698 *r_free = true;
3699
3700 return item;
3701}
3702
3703static PointerRNA rna_NodeCryptomatte_scene_get(PointerRNA *ptr)
3704{
3705 bNode *node = ptr->data_as<bNode>();
3706
3707 ID *scene = (node->custom1 == CMP_NODE_CRYPTOMATTE_SOURCE_RENDER) ? node->id : nullptr;
3708 return RNA_id_pointer_create(scene);
3709}
3710
3711static void rna_NodeCryptomatte_scene_set(PointerRNA *ptr, PointerRNA value, ReportList *reports)
3712{
3713 bNode *node = ptr->data_as<bNode>();
3714
3715 if (node->custom1 == CMP_NODE_CRYPTOMATTE_SOURCE_RENDER) {
3716 rna_Node_scene_set(ptr, value, reports);
3717 }
3718}
3719
3720static PointerRNA rna_NodeCryptomatte_image_get(PointerRNA *ptr)
3721{
3722 bNode *node = ptr->data_as<bNode>();
3723
3724 ID *image = (node->custom1 == CMP_NODE_CRYPTOMATTE_SOURCE_IMAGE) ? node->id : nullptr;
3726}
3727
3728static void rna_NodeCryptomatte_image_set(PointerRNA *ptr,
3729 PointerRNA value,
3730 ReportList * /*reports*/)
3731{
3732 bNode *node = ptr->data_as<bNode>();
3733
3734 if (node->custom1 == CMP_NODE_CRYPTOMATTE_SOURCE_IMAGE) {
3735 if (node->id) {
3736 id_us_min(node->id);
3737 }
3738 if (value) {
3739 id_us_plus(static_cast<ID *>(value.data));
3740 }
3741 node->id = static_cast<ID *>(value.data);
3742 }
3743}
3744
3745static bool rna_NodeCryptomatte_image_poll(PointerRNA * /*ptr*/, PointerRNA value)
3746{
3747 Image *image = reinterpret_cast<Image *>(value.owner_id);
3748 return image->type == IMA_TYPE_MULTILAYER;
3749}
3750
3751static void rna_NodeCryptomatte_matte_get(PointerRNA *ptr, char *value)
3752{
3753 bNode *node = ptr->data_as<bNode>();
3754 NodeCryptomatte *nc = static_cast<NodeCryptomatte *>(node->storage);
3755 char *matte_id = BKE_cryptomatte_entries_to_matte_id(nc);
3756 strcpy(value, matte_id);
3757 MEM_delete(matte_id);
3758}
3759
3760static int rna_NodeCryptomatte_matte_length(PointerRNA *ptr)
3761{
3762 bNode *node = ptr->data_as<bNode>();
3763 NodeCryptomatte *nc = static_cast<NodeCryptomatte *>(node->storage);
3764 char *matte_id = BKE_cryptomatte_entries_to_matte_id(nc);
3765 int result = strlen(matte_id);
3766 MEM_delete(matte_id);
3767 return result;
3768}
3769
3770static void rna_NodeCryptomatte_matte_set(PointerRNA *ptr, const char *value)
3771{
3772 bNode *node = ptr->data_as<bNode>();
3773 NodeCryptomatte *nc = static_cast<NodeCryptomatte *>(node->storage);
3775}
3776
3777static void rna_NodeCryptomatte_update_add(Main *bmain, Scene *scene, PointerRNA *ptr)
3778{
3781 rna_Node_update(bmain, scene, ptr);
3782}
3783
3784static void rna_NodeCryptomatte_update_remove(Main *bmain, Scene *scene, PointerRNA *ptr)
3785{
3787 rna_Node_update(bmain, scene, ptr);
3788}
3789
3790static PointerRNA rna_Node_paired_output_get(PointerRNA *ptr)
3791{
3792 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
3793 bNode *node = ptr->data_as<bNode>();
3794 const bke::bNodeZoneType &zone_type = *bke::zone_type_by_node_type(node->type_legacy);
3795 bNode *output_node = zone_type.get_corresponding_output(*ntree, *node);
3796 PointerRNA ptr_result = RNA_pointer_create_discrete(&ntree->id, RNA_Node, output_node);
3797 return ptr_result;
3798}
3799
3800static bool rna_Node_pair_with_output(
3801 ID *id, bNode *node, bContext *C, ReportList *reports, bNode *output_node)
3802{
3803 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3804 const bke::bNodeZoneType &zone_type = *bke::zone_type_by_node_type(node->type_legacy);
3805 if (output_node->type_legacy != zone_type.output_type) {
3807 reports,
3808 RPT_ERROR,
3809 "Cannot pair zone input node %s with %s because it does not have the same zone type",
3810 node->name,
3811 output_node->name);
3812 return false;
3813 }
3814 for (const bNode *other_input_node : ntree->nodes_by_type(zone_type.input_idname)) {
3815 if (other_input_node != node) {
3816 if (zone_type.get_corresponding_output(*ntree, *other_input_node) == output_node) {
3817 BKE_reportf(reports,
3818 RPT_ERROR,
3819 "The output node %s is already paired with %s",
3820 output_node->name,
3821 other_input_node->name);
3822 return false;
3823 }
3824 }
3825 }
3826 int &output_node_id = zone_type.get_corresponding_output_id(*node);
3827 output_node_id = output_node->identifier;
3828
3832 return true;
3833}
3834
3835template<typename Accessor>
3836static void rna_Node_ItemArray_remove(ID *id,
3837 bNode *node,
3838 Main *bmain,
3839 ReportList *reports,
3840 typename Accessor::ItemT *item_to_remove)
3841{
3842 nodes::socket_items::SocketItemsRef ref = Accessor::get_items_from_node(*node);
3843 if (item_to_remove < *ref.items || item_to_remove >= *ref.items + *ref.items_num) {
3844 if constexpr (Accessor::has_name) {
3845 char **name_ptr = Accessor::get_name(*item_to_remove);
3846 if (name_ptr && *name_ptr) {
3847 BKE_reportf(reports, RPT_ERROR, "Unable to locate item '%s' in node", *name_ptr);
3848 return;
3849 }
3850 }
3851 else {
3852 BKE_report(reports, RPT_ERROR, "Unable to locate item in node");
3853 }
3854 return;
3855 }
3856 const int remove_index = item_to_remove - *ref.items;
3858 ref.items, ref.items_num, ref.active_index, remove_index, Accessor::destruct_item);
3859
3860 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3862 BKE_main_ensure_invariants(*bmain, ntree->id);
3864}
3865
3866template<typename Accessor> static void rna_Node_ItemArray_clear(ID *id, bNode *node, Main *bmain)
3867{
3868 nodes::socket_items::SocketItemsRef ref = Accessor::get_items_from_node(*node);
3869 dna::array::clear(ref.items, ref.items_num, ref.active_index, Accessor::destruct_item);
3870
3871 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3873 BKE_main_ensure_invariants(*bmain, ntree->id);
3875}
3876
3877template<typename Accessor>
3878static void rna_Node_ItemArray_move(
3879 ID *id, bNode *node, Main *bmain, const int from_index, const int to_index)
3880{
3881 nodes::socket_items::SocketItemsRef ref = Accessor::get_items_from_node(*node);
3882 const int items_num = *ref.items_num;
3883 if (from_index < 0 || to_index < 0 || from_index >= items_num || to_index >= items_num) {
3884 return;
3885 }
3886 dna::array::move_index(*ref.items, items_num, from_index, to_index);
3887
3888 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3890 BKE_main_ensure_invariants(*bmain, ntree->id);
3892}
3893
3894template<typename Accessor> static PointerRNA rna_Node_ItemArray_active_get(PointerRNA *ptr)
3895{
3896 bNode *node = ptr->data_as<bNode>();
3897 nodes::socket_items::SocketItemsRef ref = Accessor::get_items_from_node(*node);
3898 typename Accessor::ItemT *active_item = nullptr;
3899 const int active_index = *ref.active_index;
3900 const int items_num = *ref.items_num;
3901 if (active_index >= 0 && active_index < items_num) {
3902 active_item = &(*ref.items)[active_index];
3903 }
3904 return RNA_pointer_create_discrete(ptr->owner_id, *Accessor::item_srna, active_item);
3905}
3906template<typename Accessor>
3907static void rna_Node_ItemArray_active_set(PointerRNA *ptr,
3908 PointerRNA value,
3909 ReportList * /*reports*/)
3910{
3911 using ItemT = typename Accessor::ItemT;
3912 bNode *node = ptr->data_as<bNode>();
3913 ItemT *item = static_cast<ItemT *>(value.data);
3914
3915 nodes::socket_items::SocketItemsRef ref = Accessor::get_items_from_node(*node);
3916 if (item >= *ref.items && item < *ref.items + *ref.items_num) {
3917 *ref.active_index = item - *ref.items;
3918 }
3919}
3920
3921template<typename Accessor>
3922static void rna_Node_ItemArray_item_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
3923{
3924 using ItemT = typename Accessor::ItemT;
3925 bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
3926 ItemT &item = *static_cast<ItemT *>(ptr->data);
3928 BLI_assert(node != nullptr);
3929
3931 BKE_main_ensure_invariants(*bmain, ntree.id);
3932}
3933
3934template<typename Accessor>
3935static const EnumPropertyItem *rna_Node_ItemArray_socket_type_itemf(bContext * /*C*/,
3936 PointerRNA *ptr,
3937 PropertyRNA * /*prop*/,
3938 bool *r_free)
3939{
3940 *r_free = true;
3941 bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
3942 return itemf_function_check(
3944 return Accessor::supports_socket_type(eNodeSocketDatatype(item->value), ntree.type);
3945 });
3946}
3947
3948template<typename Accessor>
3949static void rna_Node_ItemArray_item_name_set(PointerRNA *ptr, const char *value)
3950{
3951 using ItemT = typename Accessor::ItemT;
3952 bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
3953 ItemT &item = *static_cast<ItemT *>(ptr->data);
3955 BLI_assert(node != nullptr);
3957}
3958
3959template<typename Accessors>
3960static void rna_Node_ItemArray_item_color_get(PointerRNA *ptr, float *values)
3961{
3962 using ItemT = typename Accessors::ItemT;
3963 ItemT &item = *static_cast<ItemT *>(ptr->data);
3964 const StringRefNull socket_type_idname = *bke::node_static_socket_type(
3965 Accessors::get_socket_type(item), 0);
3966 ED_node_type_draw_color(socket_type_idname.c_str(), values);
3967}
3968
3969template<typename Accessor>
3970typename Accessor::ItemT *rna_Node_ItemArray_new_with_socket_and_name(
3971 ID *id, bNode *node, Main *bmain, ReportList *reports, int socket_type, const char *name)
3972{
3973 using ItemT = typename Accessor::ItemT;
3974
3975 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
3976 if (!Accessor::supports_socket_type(eNodeSocketDatatype(socket_type), ntree->type)) {
3977 BKE_report(reports, RPT_ERROR, "Unable to create item with this socket type");
3978 return nullptr;
3979 }
3981 *ntree, *node, eNodeSocketDatatype(socket_type), name);
3982
3984 BKE_main_ensure_invariants(*bmain, ntree->id);
3986
3987 return new_item;
3988}
3989
3990template<typename Accessor>
3991static const EnumPropertyItem *rna_Node_ItemArray_structure_type_itemf(bContext * /*C*/,
3992 PointerRNA *ptr,
3993 PropertyRNA * /*prop*/,
3994 bool *r_free)
3995{
3996 using ItemT = typename Accessor::ItemT;
3997
3998 const bNodeTree *ntree = reinterpret_cast<const bNodeTree *>(ptr->owner_id);
3999 const ItemT &item = *static_cast<const ItemT *>(ptr->data);
4000 const eNodeSocketDatatype socket_type = Accessor::get_socket_type(item);
4001 return rna_NodeSocket_structure_type_item_filter(ntree, socket_type, r_free);
4002}
4003
4005static const EnumPropertyItem *rna_GeometryNodeClosureToListItem_structure_type_itemf(
4006 bContext * /*C*/, PointerRNA *ptr, PropertyRNA * /*prop*/, bool *r_free)
4007{
4008 const bNodeTree *ntree = reinterpret_cast<const bNodeTree *>(ptr->owner_id);
4009 const auto &item = *static_cast<const GeometryNodeClosureToListItem *>(ptr->data);
4010 const auto socket_type = eNodeSocketDatatype(item.socket_type);
4011
4012 if (!ntree) {
4014 }
4015 const bool is_geometry_nodes = ntree->type == NTREE_GEOMETRY;
4016 const bool supports_fields = is_geometry_nodes &&
4018 const bool supports_grids = is_geometry_nodes && nodes::socket_type_supports_grids(socket_type);
4019 /* Lists of lists are sort of arbitrarily not supported yet. */
4020 const bool supports_lists = false;
4021
4022 *r_free = true;
4023 EnumPropertyItem *items = nullptr;
4024 int items_count = 0;
4025
4027 item++)
4028 {
4029 switch (NodeSocketInterfaceStructureType(item->value)) {
4031 RNA_enum_item_add(&items, &items_count, item);
4032 break;
4033 }
4035 break;
4036 }
4038 if (supports_fields || supports_grids) {
4039 RNA_enum_item_add(&items, &items_count, item);
4040 }
4041 break;
4042 }
4044 if (supports_fields) {
4045 RNA_enum_item_add(&items, &items_count, item);
4046 }
4047 break;
4048 }
4050 if (supports_grids) {
4051 RNA_enum_item_add(&items, &items_count, item);
4052 }
4053 break;
4054 }
4056 if (supports_lists) {
4057 RNA_enum_item_add(&items, &items_count, item);
4058 }
4059 break;
4060 }
4061 }
4062 }
4063 RNA_enum_item_end(&items, &items_count);
4064 return items;
4065}
4066
4067static IndexSwitchItem *rna_NodeIndexSwitchItems_new(ID *id, bNode *node, Main *bmain)
4068{
4070
4071 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
4073 BKE_main_ensure_invariants(*bmain, ntree->id);
4075
4076 return new_item;
4077}
4078
4079static NodeGeometryRasterizePointsItem *rna_NodeGeometryRasterizePointsItems_new(ID *id,
4080 bNode *node,
4081 Main *bmain,
4082 const char *name)
4083{
4086
4087 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
4089 BKE_main_ensure_invariants(*bmain, ntree->id);
4091
4092 return new_item;
4093}
4094
4095static CombineListItem *rna_NodeCombineListItems_new(ID *id, bNode *node, Main *bmain)
4096{
4098
4099 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
4101 BKE_main_ensure_invariants(*bmain, ntree->id);
4103
4104 return new_item;
4105}
4106
4107/* The same as #grid_socket_type_items_filter_fn. */
4108static const EnumPropertyItem *rna_NodeFieldToGridItem_data_type_itemf(bContext * /*C*/,
4109 PointerRNA * /*ptr*/,
4110 PropertyRNA * /*prop*/,
4111 bool *r_free)
4112{
4113 *r_free = true;
4114 return itemf_function_check(
4117 });
4118}
4119
4120static const EnumPropertyItem *rna_NodeGeometryCaptureAttributeItem_data_type_itemf(
4121 bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free)
4122{
4123 *r_free = true;
4124 /* See #attribute_type_type_with_socket_fn. */
4125 return itemf_function_check(rna_enum_attribute_type_items, [](const EnumPropertyItem *item) {
4126 return ELEM(item->value,
4134 });
4135}
4136
4137/* ******** Node Socket Types ******** */
4138
4139static void rna_FrameNode_label_size_update(Main *bmain, Scene *scene, PointerRNA *ptr)
4140{
4142 rna_Node_update(bmain, scene, ptr);
4143}
4144
4145static void rna_ShaderNodeTexIES_mode_set(PointerRNA *ptr, int value)
4146{
4147 bNode *node = ptr->data_as<bNode>();
4148 NodeShaderTexIES *nss = static_cast<NodeShaderTexIES *>(node->storage);
4149
4150 if (nss->mode != value) {
4151 nss->mode = value;
4152 nss->filepath[0] = '\0';
4153
4154 /* replace text datablock by filepath */
4155 if (node->id) {
4156 Text *text = reinterpret_cast<Text *>(node->id);
4157
4158 if (value == NODE_IES_EXTERNAL && text->filepath) {
4159 STRNCPY(nss->filepath, text->filepath);
4160 BLI_path_abs(nss->filepath, ID_BLEND_PATH_FROM_GLOBAL(&text->id));
4161 BLI_path_rel(nss->filepath, ID_BLEND_PATH_FROM_GLOBAL(ptr->owner_id));
4162 }
4163
4164 id_us_min(node->id);
4165 node->id = nullptr;
4166 }
4167 }
4168}
4169
4170static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
4171{
4172 bNode *node = ptr->data_as<bNode>();
4173 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
4174
4175 if (nss->mode != value) {
4176 nss->mode = value;
4177 nss->filepath[0] = '\0';
4178 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
4179
4180 /* replace text data-block by filepath */
4181 if (node->id) {
4182 Text *text = reinterpret_cast<Text *>(node->id);
4183
4184 if (value == NODE_SCRIPT_EXTERNAL && text->filepath) {
4185 STRNCPY(nss->filepath, text->filepath);
4186 BLI_path_abs(nss->filepath, ID_BLEND_PATH_FROM_GLOBAL(&text->id));
4187 BLI_path_rel(nss->filepath, ID_BLEND_PATH_FROM_GLOBAL(ptr->owner_id));
4188 }
4189
4190 id_us_min(node->id);
4191 node->id = nullptr;
4192 }
4193
4194 /* remove any bytecode */
4195 if (nss->bytecode) {
4196 MEM_delete(nss->bytecode);
4197 nss->bytecode = nullptr;
4198 }
4199
4200 nss->bytecode_hash[0] = '\0';
4201 }
4202}
4203
4204static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
4205{
4206 bNode *node = ptr->data_as<bNode>();
4207 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
4208
4209 strcpy(value, (nss->bytecode) ? nss->bytecode : "");
4210}
4211
4212static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
4213{
4214 bNode *node = ptr->data_as<bNode>();
4215 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
4216
4217 return (nss->bytecode) ? strlen(nss->bytecode) : 0;
4218}
4219
4220static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
4221{
4222 bNode *node = ptr->data_as<bNode>();
4223 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
4224
4225 if (nss->bytecode) {
4226 MEM_delete(nss->bytecode);
4227 }
4228
4229 if (value && value[0]) {
4230 nss->bytecode = BLI_strdup(value);
4231 }
4232 else {
4233 nss->bytecode = nullptr;
4234 }
4235}
4236
4237static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
4238{
4239 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
4240 bNode *node = ptr->data_as<bNode>();
4241 RenderEngineType *engine_type = (scene != nullptr) ? RE_engines_find(scene->r.engine) : nullptr;
4242
4243 if (engine_type && engine_type->update_script_node) {
4244 /* auto update node */
4245 RenderEngine *engine = RE_engine_create(engine_type);
4246 engine_type->update_script_node(engine, ntree, node);
4247 RE_engine_free(engine);
4248 }
4249
4251 BKE_main_ensure_invariants(*bmain, ntree->id);
4252}
4253
4254static void rna_ShaderNode_socket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
4255{
4256 rna_Node_update(bmain, scene, ptr);
4257}
4258
4259void rna_Node_socket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
4260{
4261 rna_Node_update(bmain, scene, ptr);
4262}
4263
4264static void rna_ShaderNode_is_active_output_set(PointerRNA *ptr, bool value)
4265{
4266 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
4267 bNode *node = ptr->data_as<bNode>();
4268 if (value) {
4269 /* If this node becomes the active output, the others of the same type can't be the active
4270 * output anymore. */
4271 for (bNode *other_node : ntree->all_nodes()) {
4272 if (other_node->type_legacy == node->type_legacy) {
4273 other_node->flag &= ~NODE_DO_OUTPUT;
4274 }
4275 }
4276 node->flag |= NODE_DO_OUTPUT;
4277 }
4278 else {
4279 node->flag &= ~NODE_DO_OUTPUT;
4280 }
4281}
4282
4283static void rna_GroupOutput_is_active_output_set(PointerRNA *ptr, bool value)
4284{
4285 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
4286 bNode *node = ptr->data_as<bNode>();
4287 if (value) {
4288 /* Make sure that no other group output is active at the same time. */
4289 for (bNode *other_node : ntree->all_nodes()) {
4290 if (other_node->is_group_output()) {
4291 other_node->flag &= ~NODE_DO_OUTPUT;
4292 }
4293 }
4294 node->flag |= NODE_DO_OUTPUT;
4295 }
4296 else {
4297 node->flag &= ~NODE_DO_OUTPUT;
4298 }
4299}
4300
4301static int rna_NodeConvertColorSpace_from_color_space_get(PointerRNA *ptr)
4302{
4303 bNode *node = ptr->data_as<bNode>();
4304 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4305 return IMB_colormanagement_colorspace_get_named_index(node_storage->from_color_space);
4306}
4307
4308static void rna_NodeConvertColorSpace_from_color_space_set(PointerRNA *ptr, int value)
4309{
4310 bNode *node = ptr->data_as<bNode>();
4311 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4312 const char *name = IMB_colormanagement_colorspace_get_indexed_name(value);
4313
4314 if (name && name[0]) {
4316 node_storage->from_color_space, node_storage->from_interop_id, name);
4317 }
4318}
4319
4320static int rna_NodeConvertColorSpace_from_interop_id_get(PointerRNA *ptr)
4321{
4322 bNode *node = ptr->data_as<bNode>();
4323 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4324 return IMB_colormanagement_colorspace_get_interop_id_index(node_storage->from_color_space,
4325 node_storage->from_interop_id);
4326}
4327
4328static void rna_NodeConvertColorSpace_from_interop_id_set(PointerRNA *ptr, int value)
4329{
4330 bNode *node = ptr->data_as<bNode>();
4331 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4333 node_storage->from_color_space, node_storage->from_interop_id, value);
4334}
4335
4336static int rna_NodeConvertColorSpace_to_color_space_get(PointerRNA *ptr)
4337{
4338 bNode *node = ptr->data_as<bNode>();
4339 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4340 return IMB_colormanagement_colorspace_get_named_index(node_storage->to_color_space);
4341}
4342
4343static void rna_NodeConvertColorSpace_to_color_space_set(PointerRNA *ptr, int value)
4344{
4345 bNode *node = ptr->data_as<bNode>();
4346 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4347 const char *name = IMB_colormanagement_colorspace_get_indexed_name(value);
4348
4349 if (name && name[0]) {
4351 node_storage->to_color_space, node_storage->to_interop_id, name);
4352 }
4353}
4354
4355static int rna_NodeConvertColorSpace_to_interop_id_get(PointerRNA *ptr)
4356{
4357 bNode *node = ptr->data_as<bNode>();
4358 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4359 return IMB_colormanagement_colorspace_get_interop_id_index(node_storage->to_color_space,
4360 node_storage->to_interop_id);
4361}
4362
4363static void rna_NodeConvertColorSpace_to_interop_id_set(PointerRNA *ptr, int value)
4364{
4365 bNode *node = ptr->data_as<bNode>();
4366 NodeConvertColorSpace *node_storage = static_cast<NodeConvertColorSpace *>(node->storage);
4368 node_storage->to_color_space, node_storage->to_interop_id, value);
4369}
4370
4371static void rna_reroute_node_socket_type_set(PointerRNA *ptr, const char *value)
4372{
4373 const bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
4374 bke::bNodeTreeType *ntree_type = ntree.typeinfo;
4375
4376 bNode &node = *ptr->data_as<bNode>();
4377
4378 if (value == nullptr) {
4379 return;
4380 }
4382 if (socket_type == nullptr) {
4383 return;
4384 }
4385 if (socket_type->subtype != PROP_NONE) {
4386 return;
4387 }
4388 if (ntree_type->valid_socket_type && !ntree_type->valid_socket_type(ntree_type, socket_type)) {
4389 return;
4390 }
4391 NodeReroute *storage = static_cast<NodeReroute *>(node.storage);
4392 STRNCPY(storage->type_idname, value);
4393}
4394
4395static void rna_implicit_conversion_node_socket_type_set(PointerRNA *ptr, const char *value)
4396{
4397 const bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
4398 bke::bNodeTreeType *ntree_type = ntree.typeinfo;
4399
4400 bNode &node = *ptr->data_as<bNode>();
4401
4402 if (value == nullptr) {
4403 return;
4404 }
4406 if (socket_type == nullptr) {
4407 return;
4408 }
4409 if (socket_type->subtype != PROP_NONE) {
4410 return;
4411 }
4412 if (ntree_type->valid_socket_type && !ntree_type->valid_socket_type(ntree_type, socket_type)) {
4413 return;
4414 }
4415 NodeImplicitConversion *storage = static_cast<NodeImplicitConversion *>(node.storage);
4416 STRNCPY(storage->type_idname, value);
4417}
4418
4419static const EnumPropertyItem *rna_NodeConvertColorSpace_interop_id_itemf(bContext * /*C*/,
4420 PointerRNA * /*ptr*/,
4421 PropertyRNA * /*prop*/,
4422 bool *r_free)
4423{
4424 EnumPropertyItem *items = nullptr;
4425 int totitem = 0;
4426
4429 RNA_enum_item_end(&items, &totitem);
4430
4431 *r_free = true;
4432
4433 return items;
4434}
4435
4436static const EnumPropertyItem *rna_NodeConvertColorSpace_color_space_itemf(bContext * /*C*/,
4437 PointerRNA * /*ptr*/,
4438 PropertyRNA * /*prop*/,
4439 bool *r_free)
4440{
4441 EnumPropertyItem *items = nullptr;
4442 int totitem = 0;
4443
4445 RNA_enum_item_end(&items, &totitem);
4446
4447 *r_free = true;
4448
4449 return items;
4450}
4451
4452static NodeEnumItem *rna_NodeMenuSwitchItems_new(ID *id,
4453 bNode *node,
4454 Main *bmain,
4455 const char *name)
4456{
4458 name);
4459
4460 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
4462 BKE_main_ensure_invariants(*bmain, ntree->id);
4464
4465 return new_item;
4466}
4467
4468static PointerRNA rna_NodeMenuSwitch_enum_definition_get(PointerRNA *ptr)
4469{
4470 /* Return node itself. The data is now directly available on the node and does not have to be
4471 * accessed through "enum_definition". */
4472 return *ptr;
4473}
4474
4475static int rna_NodeImplicitConversion_data_type_get(PointerRNA *ptr)
4476{
4477 const bNode &node = *ptr->data_as<bNode>();
4478 const NodeImplicitConversion &data = *static_cast<NodeImplicitConversion *>(node.storage);
4479 const bke::bNodeSocketType *socket_type = bke::node_socket_type_find(data.type_idname);
4480 return socket_type ? socket_type->type : SOCK_CUSTOM;
4481}
4482
4483static void rna_NodeImplicitConversion_data_type_set(PointerRNA *ptr, const int value)
4484{
4485 const bke::bNodeSocketType *socket_type = bke::node_socket_type_find_static(value);
4486 if (socket_type) {
4487 bNode &node = *ptr->data_as<bNode>();
4488 NodeImplicitConversion &data = *static_cast<NodeImplicitConversion *>(node.storage);
4489 STRNCPY(data.type_idname, socket_type->idname.c_str());
4490 }
4491}
4492
4493static const EnumPropertyItem *rna_NodeImplicitConversion_data_type_itemf(bContext * /*C*/,
4494 PointerRNA *ptr,
4495 PropertyRNA * /*prop*/,
4496 bool *r_free)
4497{
4498 *r_free = true;
4499 bNodeTree &ntree = *id_cast<bNodeTree *>(ptr->owner_id);
4500 return itemf_function_check(
4502 bke::bNodeSocketType *socket_type = bke::node_socket_type_find_static(item->value);
4503 if (!socket_type) {
4504 return false;
4505 }
4506 if (ntree.typeinfo->valid_socket_type &&
4507 !ntree.typeinfo->valid_socket_type(ntree.typeinfo, socket_type))
4508 {
4509 return false;
4510 }
4511 return true;
4512 });
4513}
4514
4515static int rna_MergeLayers_mode_get(PointerRNA *ptr)
4516{
4517 bNode *node = ptr->data_as<bNode>();
4518 const bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Mode"_ustr);
4519 return socket->default_value_typed<bNodeSocketValueMenu>()->value;
4520}
4521
4522static void rna_MergeLayers_mode_set(PointerRNA *ptr, int value)
4523{
4524 bNode *node = ptr->data_as<bNode>();
4525 bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Mode"_ustr);
4526 socket->default_value_typed<bNodeSocketValueMenu>()->value = value;
4527}
4528
4529static int rna_SetGreasePencilColor_mode_get(PointerRNA *ptr)
4530{
4531 bNode *node = ptr->data_as<bNode>();
4532 const bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Mode"_ustr);
4533 return socket->default_value_typed<bNodeSocketValueMenu>()->value;
4534}
4535
4536static void rna_SetGreasePencilColor_mode_set(PointerRNA *ptr, int value)
4537{
4538 bNode *node = ptr->data_as<bNode>();
4539 bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Mode"_ustr);
4540 socket->default_value_typed<bNodeSocketValueMenu>()->value = value;
4541}
4542
4543static int rna_SetGreasePencilDepth_depth_order_get(PointerRNA *ptr)
4544{
4545 bNode *node = ptr->data_as<bNode>();
4546 const bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Depth Order"_ustr);
4547 return socket->default_value_typed<bNodeSocketValueMenu>()->value;
4548}
4549
4550static void rna_SetGreasePencilDepth_depth_order_set(PointerRNA *ptr, int value)
4551{
4552 bNode *node = ptr->data_as<bNode>();
4553 bNodeSocket *socket = bke::node_find_socket(*node, SOCK_IN, "Depth Order"_ustr);
4554 socket->default_value_typed<bNodeSocketValueMenu>()->value = value;
4555}
4556
4557static void rna_NodeInputVector_vector_get(PointerRNA *ptr, float *values)
4558{
4559 const bNode &node = *ptr->data_as<bNode>();
4560 const auto &storage = *static_cast<NodeInputVector *>(node.storage);
4561 memcpy(values, storage.vector, sizeof(float) * storage.dimensions);
4562}
4563
4564static void rna_NodeInputVector_vector_set(PointerRNA *ptr, const float *values)
4565{
4566 bNode &node = *ptr->data_as<bNode>();
4567 auto &storage = *static_cast<NodeInputVector *>(node.storage);
4568 memcpy(storage.vector, values, sizeof(float) * storage.dimensions);
4569}
4570
4571static int rna_NodeInputVector_vector_get_array_length(const PointerRNA *ptr,
4573{
4574 const bNode &node = *ptr->data_as<bNode>();
4575 const auto &storage = *static_cast<NodeInputVector *>(node.storage);
4577 return storage.dimensions;
4578}
4579
4580static void rna_NodeInputIntVector_vector_get(PointerRNA *ptr, int *values)
4581{
4582 const bNode &node = *ptr->data_as<bNode>();
4583 const auto &storage = *static_cast<NodeInputIntVector *>(node.storage);
4584 memcpy(values, storage.vector, sizeof(int) * storage.dimensions);
4585}
4586
4587static void rna_NodeInputIntVector_vector_set(PointerRNA *ptr, const int *values)
4588{
4589 bNode &node = *ptr->data_as<bNode>();
4590 auto &storage = *static_cast<NodeInputIntVector *>(node.storage);
4591 memcpy(storage.vector, values, sizeof(int) * storage.dimensions);
4592}
4593
4594static int rna_NodeInputIntVector_vector_get_array_length(const PointerRNA *ptr,
4596{
4597 const bNode &node = *ptr->data_as<bNode>();
4598 const auto &storage = *static_cast<NodeInputIntVector *>(node.storage);
4600 return storage.dimensions;
4601}
4602
4603const EnumPropertyItem *rna_NodeInputMenu_menu_itemf(bContext * /*C*/,
4604 PointerRNA *ptr,
4605 PropertyRNA *prop,
4606 bool *r_free)
4607{
4608 const bNode *node = static_cast<bNode *>(ptr->data);
4609 const bNodeSocket *socket = node->outputs.first();
4610 if (!socket) {
4611 *r_free = false;
4613 }
4614 const bNodeSocketValueMenu *data = static_cast<bNodeSocketValueMenu *>(socket->default_value);
4615 if (!data->enum_items) {
4616 *r_free = false;
4618 }
4619 const char *socket_translation_context = bke::node_socket_translation_context(*socket);
4620 RNA_def_property_translation_context(prop, socket_translation_context);
4621 return RNA_node_enum_definition_itemf(*data->enum_items, r_free);
4622}
4623
4624static const EnumPropertyItem *rna_NodeRaycastSampleAttributeItem_data_type_itemf(
4625 bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free)
4626{
4627 *r_free = true;
4628 /* See #attribute_type_type_with_socket_fn. */
4629 return itemf_function_check(rna_enum_attribute_type_items, [](const EnumPropertyItem *item) {
4630 return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_COLOR);
4631 });
4632}
4633
4634static const EnumPropertyItem *rna_NodeShaderAttribute_type_itemf(bContext *C,
4635 PointerRNA * /*ptr*/,
4636 PropertyRNA * /*prop*/,
4637 bool *r_free)
4638{
4639 if (C == nullptr) {
4641 }
4642
4643 Scene *scene = CTX_data_scene(C);
4644 SpaceNode *space_node = CTX_wm_space_node(C);
4645
4646 if (scene == nullptr || space_node == nullptr) {
4648 }
4649
4650 *r_free = true;
4651
4652 bool supports_light_attributes = !STREQ(CTX_data_scene(C)->r.engine, RE_engine_id_CYCLES) &&
4654 return itemf_function_check(
4656 return supports_light_attributes || item->value != SHD_ATTRIBUTE_LIGHT;
4657 });
4658}
4659
4660static const EnumPropertyItem *rna_NodeShaderVectTransform_space_itemf(bContext *C,
4661 PointerRNA * /*ptr*/,
4662 PropertyRNA * /*prop*/,
4663 bool *r_free)
4664{
4665 if (C == nullptr) {
4667 }
4668
4669 Scene *scene = CTX_data_scene(C);
4670 SpaceNode *space_node = CTX_wm_space_node(C);
4671
4672 if (scene == nullptr || space_node == nullptr) {
4674 }
4675
4676 *r_free = true;
4677
4678 bool supports_light_transform = !STREQ(CTX_data_scene(C)->r.engine, RE_engine_id_CYCLES) &&
4680 return itemf_function_check(
4682 return supports_light_transform || item->value != SHD_VECT_TRANSFORM_SPACE_LIGHT;
4683 });
4684}
4685
4686} // namespace blender
4687
4688#else
4689
4690namespace blender {
4691
4693 {0, "PLACEHOLDER", 0, "Placeholder", ""},
4694 {0, nullptr, 0, nullptr, nullptr},
4695};
4696
4698 {0, "ALL", 0, "All", ""},
4699 {0, nullptr, 0, nullptr, nullptr},
4700};
4701
4703 {0, "PLACEHOLDER", 0, "Placeholder", ""},
4704 {0, nullptr, 0, nullptr, nullptr},
4705};
4706
4708 {0, "ITUBT601", 0, "ITU 601", ""},
4709 {1, "ITUBT709", 0, "ITU 709", ""},
4710 {2, "JFIF", 0, "JPEG", ""},
4711 {0, nullptr, 0, nullptr, nullptr},
4712};
4713
4715 {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
4716 {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
4718 "MULTI_GGX",
4719 0,
4720 "Multiscatter GGX",
4721 "GGX with additional correction to account for multiple scattering, preserve energy and "
4722 "prevent unexpected darkening at high roughness"},
4723 {0, nullptr, 0, nullptr, nullptr},
4724};
4725
4728 "PHYSICAL_CONDUCTOR",
4729 0,
4730 "Physical Conductor",
4731 "Fresnel conductor based on the complex refractive index per color channel"},
4733 "F82",
4734 0,
4735 "F82 Tint",
4736 "An approximation of the Fresnel conductor curve based on the colors at perpendicular and "
4737 "near-grazing (roughly 82°) angles"},
4738 {0, nullptr, 0, nullptr, nullptr},
4739};
4740
4742 {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
4743 {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
4744 {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
4746 "MULTI_GGX",
4747 0,
4748 "Multiscatter GGX",
4749 "GGX with additional correction to account for multiple scattering, preserve energy and "
4750 "prevent unexpected darkening at high roughness"},
4751 {0, nullptr, 0, nullptr, nullptr},
4752};
4753
4755 {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
4756 {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
4758 "MULTI_GGX",
4759 0,
4760 "Multiscatter GGX",
4761 "GGX with additional correction to account for multiple scattering, preserve energy and "
4762 "prevent unexpected darkening at high roughness"},
4763 {0, nullptr, 0, nullptr, nullptr},
4764};
4765
4767 {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
4768 {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
4769 {0, nullptr, 0, nullptr, nullptr},
4770};
4771
4773 {SHD_SHEEN_ASHIKHMIN, "ASHIKHMIN", 0, "Ashikhmin", "Classic Ashikhmin velvet (legacy model)"},
4775 "MICROFIBER",
4776 0,
4777 "Microfiber",
4778 "Microflake-based model of multiple scattering between normal-oriented fibers"},
4779 {0, nullptr, 0, nullptr, nullptr},
4780};
4781
4783 {SHD_TOON_DIFFUSE, "DIFFUSE", 0, "Diffuse", "Use diffuse BSDF"},
4784 {SHD_TOON_GLOSSY, "GLOSSY", 0, "Glossy", "Use glossy BSDF"},
4785 {0, nullptr, 0, nullptr, nullptr},
4786};
4787
4790 "Reflection",
4791 0,
4792 "Reflection",
4793 "The light that bounces off the surface of the hair"},
4795 "Transmission",
4796 0,
4797 "Transmission",
4798 "The light that passes through the hair and exits on the other side"},
4799 {0, nullptr, 0, nullptr, nullptr},
4800};
4801
4804 "CHIANG",
4805 0,
4806 "Chiang",
4807 "Near-field hair scattering model by Chiang et al. 2016, suitable for close-up looks, but is "
4808 "more noisy when viewing from a distance."},
4810 "HUANG",
4811 0,
4812 "Huang",
4813 "Multi-scale hair scattering model by Huang et al. 2022, suitable for viewing both up close "
4814 "and from a distance, supports elliptical cross-sections and has more precise highlight in "
4815 "forward scattering directions."},
4816 {0, nullptr, 0, nullptr, nullptr},
4817};
4818
4821 "ABSORPTION",
4822 0,
4823 "Absorption Coefficient",
4824 "Directly set the absorption coefficient \"sigma_a\" (this is not the most intuitive way to "
4825 "color hair)"},
4827 "MELANIN",
4828 0,
4829 "Melanin Concentration",
4830 "Define the melanin concentrations below to get the most realistic-looking hair (you can get "
4831 "the concentrations for different types of hair online)"},
4833 "COLOR",
4834 0,
4835 "Direct Coloring",
4836 "Choose the color of your preference, and the shader will approximate the absorption "
4837 "coefficient to render lookalike hair"},
4838 {0, nullptr, 0, nullptr, nullptr},
4839};
4840
4842 {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text data-block"},
4843 {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
4844 {0, nullptr, 0, nullptr, nullptr},
4845};
4846
4848 {NODE_IES_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text data-block"},
4849 {NODE_IES_EXTERNAL, "EXTERNAL", 0, "External", "Use external .ies file"},
4850 {0, nullptr, 0, nullptr, nullptr},
4851};
4852
4854 {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
4856 "MULTI_GGX",
4857 0,
4858 "Multiscatter GGX",
4859 "GGX with additional correction to account for multiple scattering, preserve energy and "
4860 "prevent unexpected darkening at high roughness"},
4861 {0, nullptr, 0, nullptr, nullptr},
4862};
4863
4865 {SHD_LIGHT_EVAL_DIFFUSE, "DIFFUSE", 0, "Diffuse", ""},
4866 {SHD_LIGHT_EVAL_GLOSSY, "GLOSSY", 0, "Glossy", ""},
4867 {0, nullptr, 0, nullptr, nullptr},
4868};
4869
4872 "BURLEY",
4873 0,
4874 "Christensen-Burley",
4875 "Approximation to physically based volume scattering"},
4877 "RANDOM_WALK",
4878 0,
4879 "Random Walk",
4880 "Volumetric approximation to physically based volume scattering, using the scattering radius "
4881 "as specified"},
4883 "RANDOM_WALK_SKIN",
4884 0,
4885 "Random Walk (Skin)",
4886 "Volumetric approximation to physically based volume scattering, with scattering radius "
4887 "automatically adjusted to match color textures. Designed for skin shading."},
4889 "RANDOM_WALK_LEGACY",
4890 0,
4891 "Random Walk (Legacy)",
4892 "Volumetric approximation to physically based volume scattering, using the scattering radius "
4893 "as specified"},
4894 {0, nullptr, 0, nullptr, nullptr}};
4895
4898 "REPEAT",
4899 0,
4900 "Repeat",
4901 "Cause the image to repeat horizontally and vertically"},
4903 "EXTEND",
4904 0,
4905 "Extend",
4906 "Extend by repeating edge pixels of the image"},
4908 "CLIP",
4909 0,
4910 "Clip",
4911 "Clip to image size and set exterior pixels as transparent"},
4913 "MIRROR",
4914 0,
4915 "Mirror",
4916 "Repeatedly flip the image horizontally and vertically"},
4917 {0, nullptr, 0, nullptr, nullptr},
4918};
4919
4922 "HENYEY_GREENSTEIN",
4923 0,
4924 "Henyey-Greenstein",
4925 "Henyey-Greenstein, default phase function for the scattering of light"},
4927 "FOURNIER_FORAND",
4928 0,
4929 "Fournier-Forand",
4930 "Fournier-Forand phase function, used for the scattering of light in underwater "
4931 "environments"},
4933 "DRAINE",
4934 0,
4935 "Draine",
4936 "Draine phase functions, mostly used for the scattering of light in interstellar dust"},
4938 "RAYLEIGH",
4939 0,
4940 "Rayleigh",
4941 "Rayleigh phase function, mostly used for particles smaller than the wavelength of light, "
4942 "such as scattering of sunlight in earth's atmosphere"},
4944 "MIE",
4945 0,
4946 "Mie",
4947 "Approximation of Mie scattering in water droplets, used for scattering in clouds and fog"},
4948 {0, nullptr, 0, nullptr, nullptr},
4949};
4950
4952 StructRNA *srna,
4953 const char *accessor,
4954 const bool add_socket_type,
4955 const bool add_vector_socket_dimensions = false)
4956{
4957 static LinearAllocator<> allocator;
4958 PropertyRNA *prop;
4959
4960 char name_set_func[128];
4961 SNPRINTF(name_set_func, "rna_Node_ItemArray_item_name_set<%s>", accessor);
4962
4963 char item_update_func[128];
4964 SNPRINTF(item_update_func, "rna_Node_ItemArray_item_update<%s>", accessor);
4965 const char *item_update_func_ptr = allocator.copy_string(item_update_func).c_str();
4966
4967 char socket_type_itemf[128];
4968 SNPRINTF(socket_type_itemf, "rna_Node_ItemArray_socket_type_itemf<%s>", accessor);
4969
4970 char color_get_func[128];
4971 SNPRINTF(color_get_func, "rna_Node_ItemArray_item_color_get<%s>", accessor);
4972
4973 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
4975 prop, nullptr, nullptr, allocator.copy_string(name_set_func).c_str());
4976 RNA_def_property_ui_text(prop, "Name", "");
4977 RNA_def_struct_name_property(srna, prop);
4978 RNA_def_property_update(prop, NC_NODE | NA_EDITED, item_update_func_ptr);
4979
4980 if (add_socket_type) {
4981 prop = RNA_def_property(srna, "socket_type", PROP_ENUM, PROP_NONE);
4984 prop, nullptr, nullptr, allocator.copy_string(socket_type_itemf).c_str());
4985 RNA_def_property_ui_text(prop, "Socket Type", "");
4987 RNA_def_property_update(prop, NC_NODE | NA_EDITED, item_update_func_ptr);
4988
4989 if (add_vector_socket_dimensions) {
4990 prop = RNA_def_property(srna, "vector_socket_dimensions", PROP_INT, PROP_NONE);
4991 RNA_def_property_int_sdna(prop, nullptr, "vector_socket_dimensions");
4992 RNA_def_property_range(prop, 2, 4);
4994 RNA_def_property_ui_text(prop, "Dimensions", "Dimensions of the vector socket");
4995 RNA_def_property_update(prop, NC_NODE | NA_EDITED, item_update_func_ptr);
4996 }
4997 }
4998
4999 prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
5000 RNA_def_property_array(prop, 4);
5002 prop, allocator.copy_string(color_get_func).c_str(), nullptr, nullptr);
5005 prop, "Color", "Color of the corresponding socket type in the node editor");
5006}
5007
5009 const char *item_name,
5010 const char *accessor_name)
5011{
5012 static LinearAllocator<> allocator;
5013 PropertyRNA *parm;
5014 FunctionRNA *func;
5015
5016 char remove_call[128];
5017 SNPRINTF(remove_call, "rna_Node_ItemArray_remove<%s>", accessor_name);
5018 char clear_call[128];
5019 SNPRINTF(clear_call, "rna_Node_ItemArray_clear<%s>", accessor_name);
5020 char move_call[128];
5021 SNPRINTF(move_call, "rna_Node_ItemArray_move<%s>", accessor_name);
5022
5023 func = RNA_def_function(srna, "remove", allocator.copy_string(remove_call).c_str());
5024 RNA_def_function_ui_description(func, "Remove an item");
5026 parm = RNA_def_pointer(func, "item", item_name, "Item", "The item to remove");
5028
5029 func = RNA_def_function(srna, "clear", allocator.copy_string(clear_call).c_str());
5030 RNA_def_function_ui_description(func, "Remove all items");
5032
5033 func = RNA_def_function(srna, "move", allocator.copy_string(move_call).c_str());
5034 RNA_def_function_ui_description(func, "Move an item to another position");
5036 parm = RNA_def_int(
5037 func, "from_index", -1, 0, INT_MAX, "From Index", "Index of the item to move", 0, 10000);
5039 parm = RNA_def_int(
5040 func, "to_index", -1, 0, INT_MAX, "To Index", "Target index for the item", 0, 10000);
5042}
5043
5045 const char *item_name,
5046 const char *accessor_name)
5047{
5048 static LinearAllocator<> allocator;
5049 PropertyRNA *parm;
5050 FunctionRNA *func;
5051
5052 char name[128];
5053 SNPRINTF(name, "rna_Node_ItemArray_new_with_socket_and_name<%s>", accessor_name);
5054
5055 func = RNA_def_function(srna, "new", allocator.copy_string(name).c_str());
5056 RNA_def_function_ui_description(func, "Add an item at the end");
5058 parm = RNA_def_enum(func,
5059 "socket_type",
5062 "Socket Type",
5063 "Socket type of the item");
5065 parm = RNA_def_string(func, "name", nullptr, MAX_NAME, "Name", "");
5067 /* return value */
5068 parm = RNA_def_pointer(func, "item", item_name, "Item", "New item");
5070 RNA_def_function_return(func, parm);
5071}
5072
5073/* -- Common nodes ---------------------------------------------------------- */
5074
5075static void def_group_input(BlenderRNA * /*brna*/, StructRNA * /*srna*/) {}
5076
5077static void def_group_output(BlenderRNA * /*brna*/, StructRNA *srna)
5078{
5079 PropertyRNA *prop;
5080
5081 prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
5082 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_DO_OUTPUT);
5084 prop, "Active Output", "True if this node is used as the active group output");
5085 RNA_def_property_boolean_funcs(prop, nullptr, "rna_GroupOutput_is_active_output_set");
5086 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5087}
5088
5089static void def_group(BlenderRNA * /*brna*/, StructRNA *srna)
5090{
5091 PropertyRNA *prop;
5092
5093 prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
5094 RNA_def_property_pointer_sdna(prop, nullptr, "id");
5095 RNA_def_property_struct_type(prop, "NodeTree");
5097 prop, nullptr, "rna_NodeGroup_node_tree_set", nullptr, "rna_NodeGroup_node_tree_poll");
5100 RNA_def_property_ui_text(prop, "Node Tree", "");
5101 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
5102}
5103
5105 const char *struct_name,
5106 const char *base_name,
5107 const char *ui_name,
5108 const char *ui_desc,
5109 const char *reg_func)
5110{
5111 StructRNA *srna;
5112
5113 srna = RNA_def_struct(brna, struct_name, base_name);
5114 RNA_def_struct_ui_text(srna, ui_name, ui_desc);
5115 RNA_def_struct_sdna(srna, "bNode");
5116
5117 RNA_def_struct_register_funcs(srna, reg_func, "rna_Node_unregister", nullptr);
5118
5119 def_group(brna, srna);
5120}
5121
5122static void def_frame(BlenderRNA * /*brna*/, StructRNA *srna)
5123{
5124 PropertyRNA *prop;
5125
5126 prop = RNA_def_property(srna, "text", PROP_POINTER, PROP_NONE);
5127 RNA_def_property_pointer_sdna(prop, nullptr, "id");
5128 RNA_def_property_struct_type(prop, "Text");
5131 RNA_def_property_ui_text(prop, "Text", "");
5132 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5133
5134 RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
5136
5137 prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
5138 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_FRAME_SHRINK);
5140 RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
5141 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
5142
5143 prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
5144 RNA_def_property_int_sdna(prop, nullptr, "label_size");
5145 RNA_def_property_range(prop, 8, 64);
5147 RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
5148 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_FrameNode_label_size_update");
5149}
5150
5151static void def_clamp(BlenderRNA * /*brna*/, StructRNA *srna)
5152{
5153 PropertyRNA *prop;
5154
5155 prop = RNA_def_property(srna, "clamp_type", PROP_ENUM, PROP_NONE);
5156 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5158 RNA_def_property_ui_text(prop, "Clamp Type", "");
5159 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5160}
5161
5162static void def_map_range(BlenderRNA * /*brna*/, StructRNA *srna)
5163{
5164 static const EnumPropertyItem rna_enum_data_type_items[] = {
5165 {CD_PROP_FLOAT, "FLOAT", ICON_NODE_SOCKET_FLOAT, "Float", "Floating-point value"},
5167 "FLOAT_VECTOR",
5168 ICON_NODE_SOCKET_VECTOR,
5169 "Vector",
5170 "3D vector with floating-point values"},
5171 {0, nullptr, 0, nullptr, nullptr},
5172 };
5173
5174 RNA_def_struct_sdna_from(srna, "NodeMapRange", "storage");
5175
5176 PropertyRNA *prop;
5177
5178 prop = RNA_def_property(srna, "clamp", PROP_BOOLEAN, PROP_NONE);
5179 RNA_def_property_boolean_sdna(prop, nullptr, "clamp", 1);
5180 RNA_def_property_ui_text(prop, "Clamp", "Clamp the result to the target range [To Min, To Max]");
5182 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5183
5184 prop = RNA_def_property(srna, "interpolation_type", PROP_ENUM, PROP_NONE);
5185 RNA_def_property_enum_sdna(prop, nullptr, "interpolation_type");
5187 RNA_def_property_ui_text(prop, "Interpolation Type", "");
5188 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5189
5190 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
5191 RNA_def_property_enum_bitflag_sdna(prop, nullptr, "data_type");
5192 RNA_def_property_enum_items(prop, rna_enum_data_type_items);
5193 RNA_def_property_ui_text(prop, "Data Type", "");
5194 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5195}
5196
5197static void def_math(BlenderRNA * /*brna*/, StructRNA *srna)
5198{
5199 PropertyRNA *prop;
5200
5201 prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
5202 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5204 RNA_def_property_ui_text(prop, "Operation", "");
5206 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5208
5209 prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
5210 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", SHD_MATH_CLAMP);
5211 RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0.0 to 1.0 range");
5212 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5213}
5214
5215static void def_sh_mix(BlenderRNA * /*brna*/, StructRNA *srna)
5216{
5217 static const EnumPropertyItem rna_enum_mix_mode_items[] = {
5218 {NODE_MIX_MODE_UNIFORM, "UNIFORM", 0, "Uniform", "Use a single factor for all components"},
5219 {NODE_MIX_MODE_NON_UNIFORM, "NON_UNIFORM", 0, "Non-Uniform", "Per component factor"},
5220 {0, nullptr, 0, nullptr, nullptr},
5221 };
5222
5223 PropertyRNA *prop;
5224
5225 RNA_def_struct_sdna_from(srna, "NodeShaderMix", "storage");
5226
5227 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
5228 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_ShaderNodeMix_data_type_itemf");
5231 RNA_def_property_ui_text(prop, "Data Type", "");
5232 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
5233
5234 prop = RNA_def_property(srna, "factor_mode", PROP_ENUM, PROP_NONE);
5235 RNA_def_property_enum_items(prop, rna_enum_mix_mode_items);
5237 RNA_def_property_ui_text(prop, "Factor Mode", "");
5238 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
5239
5240 prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
5241 RNA_def_property_enum_sdna(prop, nullptr, "blend_type");
5243 RNA_def_property_ui_text(prop, "Blending Mode", "");
5244 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5245
5246 prop = RNA_def_property(srna, "clamp_factor", PROP_BOOLEAN, PROP_NONE);
5247 RNA_def_property_boolean_sdna(prop, nullptr, "clamp_factor", 1);
5249 RNA_def_property_ui_text(prop, "Clamp Factor", "Clamp the factor to [0,1] range");
5250 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5251
5252 prop = RNA_def_property(srna, "clamp_result", PROP_BOOLEAN, PROP_NONE);
5253 RNA_def_property_boolean_sdna(prop, nullptr, "clamp_result", 1);
5254 RNA_def_property_ui_text(prop, "Clamp Result", "Clamp the result to [0,1] range");
5255 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5256}
5257
5258static void def_float_to_int(BlenderRNA * /*brna*/, StructRNA *srna)
5259{
5260 PropertyRNA *prop;
5261
5262 prop = RNA_def_property(srna, "rounding_mode", PROP_ENUM, PROP_NONE);
5263 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5266 prop, "Rounding Mode", "Method used to convert the float to an integer");
5268 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5269}
5270
5271static void def_vector_math(BlenderRNA * /*brna*/, StructRNA *srna)
5272{
5273 PropertyRNA *prop;
5274
5275 prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
5276 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5278 RNA_def_property_ui_text(prop, "Operation", "");
5280 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5282}
5283
5284static void def_rgb_curve(BlenderRNA * /*brna*/, StructRNA *srna)
5285{
5286 PropertyRNA *prop;
5287
5288 prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
5289 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
5290 RNA_def_property_struct_type(prop, "CurveMapping");
5291 RNA_def_property_ui_text(prop, "Mapping", "");
5292 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5293}
5294
5295static void def_vector_curve(BlenderRNA * /*brna*/, StructRNA *srna)
5296{
5297 PropertyRNA *prop;
5298
5299 prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
5300 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
5301 RNA_def_property_struct_type(prop, "CurveMapping");
5302 RNA_def_property_ui_text(prop, "Mapping", "");
5303 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5304}
5305
5306static void def_float_curve(BlenderRNA * /*brna*/, StructRNA *srna)
5307{
5308 PropertyRNA *prop;
5309
5310 prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
5311 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
5312 RNA_def_property_struct_type(prop, "CurveMapping");
5313 RNA_def_property_ui_text(prop, "Mapping", "");
5314 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5315}
5316
5317static void def_time(BlenderRNA * /*brna*/, StructRNA *srna)
5318{
5319 PropertyRNA *prop;
5320
5321 prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
5322 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
5323 RNA_def_property_struct_type(prop, "CurveMapping");
5324 RNA_def_property_ui_text(prop, "Curve", "");
5325 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5326}
5327
5328static void def_colorramp(BlenderRNA * /*brna*/, StructRNA *srna)
5329{
5330 PropertyRNA *prop;
5331
5332 prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
5333 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
5334 RNA_def_property_struct_type(prop, "ColorRamp");
5335 RNA_def_property_ui_text(prop, "Color Ramp", "");
5336 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5337}
5338
5339static void def_mix_rgb(BlenderRNA * /*brna*/, StructRNA *srna)
5340{
5341 PropertyRNA *prop;
5342
5343 prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
5344 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5346 RNA_def_property_ui_text(prop, "Blending Mode", "");
5347 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5348
5349 prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
5350 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", SHD_MIXRGB_USE_ALPHA);
5351 RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
5352 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5353
5354 prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
5355 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", SHD_MIXRGB_CLAMP);
5356 RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0.0 to 1.0 range");
5357 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5358}
5359
5360static void def_texture(BlenderRNA * /*brna*/, StructRNA *srna)
5361{
5362 PropertyRNA *prop;
5363
5364 prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
5365 RNA_def_property_pointer_sdna(prop, nullptr, "id");
5366 RNA_def_property_struct_type(prop, "Texture");
5369 RNA_def_property_ui_text(prop, "Texture", "");
5370 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
5371
5372 prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
5373 RNA_def_property_int_sdna(prop, nullptr, "custom1");
5375 prop, "Node Output", "For node-based textures, which output node to use");
5376 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5377}
5378
5379static void def_fn_input_color(BlenderRNA * /*brna*/, StructRNA *srna)
5380{
5381 PropertyRNA *prop;
5382
5383 RNA_def_struct_sdna_from(srna, "NodeInputColor", "storage");
5384
5385 prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_COLOR);
5386 RNA_def_property_array(prop, 4);
5387 RNA_def_property_float_sdna(prop, nullptr, "color");
5388 RNA_def_property_ui_text(prop, "Color", "");
5389 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5390}
5391
5392static void def_fn_input_bool(BlenderRNA * /*brna*/, StructRNA *srna)
5393{
5394 PropertyRNA *prop;
5395
5396 RNA_def_struct_sdna_from(srna, "NodeInputBool", "storage");
5397
5398 prop = RNA_def_property(srna, "boolean", PROP_BOOLEAN, PROP_NONE);
5399 RNA_def_property_boolean_sdna(prop, nullptr, "boolean", 1);
5400 RNA_def_property_ui_text(prop, "Boolean", "Input value used for unconnected socket");
5401 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5402}
5403
5404static void def_fn_input_int(BlenderRNA * /*brna*/, StructRNA *srna)
5405{
5406 PropertyRNA *prop;
5407
5408 RNA_def_struct_sdna_from(srna, "NodeInputInt", "storage");
5409
5410 prop = RNA_def_property(srna, "integer", PROP_INT, PROP_NONE);
5411 RNA_def_property_int_sdna(prop, nullptr, "integer");
5412 RNA_def_property_ui_text(prop, "Integer", "Input value used for unconnected socket");
5413 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5414}
5415
5416static void def_fn_input_menu(BlenderRNA * /*brna*/, StructRNA *srna)
5417{
5418 PropertyRNA *prop;
5419
5420 RNA_def_struct_sdna_from(srna, "NodeInputMenu", "storage");
5421
5422 prop = RNA_def_property(srna, "value", PROP_ENUM, PROP_NONE);
5424 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeInputMenu_menu_itemf");
5425 RNA_def_property_ui_text(prop, "Menu", "Value of the output socket");
5426 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5428}
5429
5430static void def_fn_input_rotation(BlenderRNA * /*brna*/, StructRNA *srna)
5431{
5432 PropertyRNA *prop;
5433
5434 RNA_def_struct_sdna_from(srna, "NodeInputRotation", "storage");
5435
5436 prop = RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
5437 RNA_def_property_float_sdna(prop, nullptr, "rotation_euler");
5438 RNA_def_property_ui_text(prop, "Rotation", "Input value used for unconnected socket");
5439 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5440}
5441
5442static void def_fn_input_vector(BlenderRNA * /*brna*/, StructRNA *srna)
5443{
5444 PropertyRNA *prop;
5445
5446 RNA_def_struct_sdna_from(srna, "NodeInputVector", "storage");
5447
5448 prop = RNA_def_property(srna, "vector", PROP_FLOAT, PROP_XYZ);
5450 /* Note: Must be called before function definitions below, so that arraydimension is set. */
5451 RNA_def_property_array(prop, 4);
5453 prop, "rna_NodeInputVector_vector_get", "rna_NodeInputVector_vector_set", nullptr);
5454 RNA_def_property_dynamic_array_funcs(prop, "rna_NodeInputVector_vector_get_array_length");
5455 RNA_def_property_ui_text(prop, "Vector", "");
5456 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5457
5458 prop = RNA_def_property(srna, "vector_dimensions", PROP_INT, PROP_NONE);
5459 RNA_def_property_int_sdna(prop, nullptr, "dimensions");
5460 RNA_def_property_range(prop, 2, 4);
5462 RNA_def_property_ui_text(prop, "Dimensions", "Dimensions of the vector socket");
5463 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5464}
5465
5466static void def_fn_input_int_vector(BlenderRNA * /*brna*/, StructRNA *srna)
5467{
5468 PropertyRNA *prop;
5469
5470 RNA_def_struct_sdna_from(srna, "NodeInputIntVector", "storage");
5471
5472 prop = RNA_def_property(srna, "vector", PROP_INT, PROP_NONE);
5474 /* Note: Must be called before function definitions below, so that arraydimension is set. */
5475 RNA_def_property_array(prop, 3);
5477 prop, "rna_NodeInputIntVector_vector_get", "rna_NodeInputIntVector_vector_set", nullptr);
5478 RNA_def_property_dynamic_array_funcs(prop, "rna_NodeInputIntVector_vector_get_array_length");
5479 RNA_def_property_ui_text(prop, "Vector", "");
5480 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5481
5482 prop = RNA_def_property(srna, "vector_dimensions", PROP_INT, PROP_NONE);
5483 RNA_def_property_int_sdna(prop, nullptr, "dimensions");
5484 RNA_def_property_range(prop, 2, 3);
5486 RNA_def_property_ui_text(prop, "Dimensions", "Dimensions of the vector socket");
5487 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5488}
5489
5490static void def_fn_input_string(BlenderRNA * /*brna*/, StructRNA *srna)
5491{
5492 PropertyRNA *prop;
5493
5494 RNA_def_struct_sdna_from(srna, "NodeInputString", "storage");
5495
5496 prop = RNA_def_property(srna, "string", PROP_STRING, PROP_NONE);
5497 RNA_def_property_ui_text(prop, "String", "");
5499 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5500
5501 prop = RNA_def_property(srna, "textbox_state", PROP_POINTER, PROP_NONE);
5502 RNA_def_property_struct_type(prop, "TextboxState");
5503 RNA_def_property_pointer_sdna(prop, nullptr, "textbox_state");
5504}
5505
5506/* -- Shader Nodes ---------------------------------------------------------- */
5507
5508static void def_sh_output(BlenderRNA * /*brna*/, StructRNA *srna)
5509{
5510 PropertyRNA *prop;
5511
5512 prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
5513 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_DO_OUTPUT);
5515 prop, "Active Output", "True if this node is used as the active output");
5516 RNA_def_property_boolean_funcs(prop, nullptr, "rna_ShaderNode_is_active_output_set");
5517 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5518
5519 prop = RNA_def_property(srna, "target", PROP_ENUM, PROP_NONE);
5520 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5523 prop, "Target", "Which renderer and viewport shading types to use the shaders for");
5524 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5525}
5526
5528{
5529 def_sh_output(brna, srna);
5530 def_mix_rgb(brna, srna);
5531}
5532
5533static void def_sh_mapping(BlenderRNA * /*brna*/, StructRNA *srna)
5534{
5535 PropertyRNA *prop;
5536
5537 prop = RNA_def_property(srna, "vector_type", PROP_ENUM, PROP_NONE);
5538 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5540 RNA_def_property_ui_text(prop, "Type", "Type of vector that the mapping transforms");
5541 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5542}
5543
5544static void def_sh_vector_rotate(BlenderRNA * /*brna*/, StructRNA *srna)
5545{
5546 PropertyRNA *prop;
5547
5548 prop = RNA_def_property(srna, "rotation_type", PROP_ENUM, PROP_NONE);
5549 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5551 RNA_def_property_ui_text(prop, "Type", "Type of angle input");
5552 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
5553
5554 prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
5555 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", 0);
5556 RNA_def_property_ui_text(prop, "Invert", "Invert the rotation angle");
5557 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5558}
5559
5560static void def_sh_attribute(BlenderRNA * /*brna*/, StructRNA *srna)
5561{
5562 PropertyRNA *prop;
5563
5564 RNA_def_struct_sdna_from(srna, "NodeShaderAttribute", "storage");
5565
5566 prop = RNA_def_property(srna, "attribute_type", PROP_ENUM, PROP_NONE);
5567 RNA_def_property_enum_sdna(prop, nullptr, "type");
5568 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeShaderAttribute_type_itemf");
5570 RNA_def_property_ui_text(prop, "Attribute Type", "General type of the attribute");
5571 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
5572
5573 prop = RNA_def_property(srna, "attribute_name", PROP_STRING, PROP_NONE);
5574 RNA_def_property_string_sdna(prop, nullptr, "name");
5575 RNA_def_property_ui_text(prop, "Attribute Name", "");
5576 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
5577}
5578
5579static void def_sh_tex(BlenderRNA * /*brna*/, StructRNA *srna)
5580{
5581 PropertyRNA *prop;
5582
5583 prop = RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
5584 RNA_def_property_pointer_sdna(prop, nullptr, "base.tex_mapping");
5586 RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
5587
5588 prop = RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
5589 RNA_def_property_pointer_sdna(prop, nullptr, "base.color_mapping");
5591 RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
5592}
5593
5594static void def_sh_tex_sky(BlenderRNA *brna, StructRNA *srna)
5595{
5596 static const EnumPropertyItem prop_sky_type[] = {
5598 "SINGLE_SCATTERING",
5599 0,
5600 "Single Scattering",
5601 "Single scattering sky model"},
5603 "MULTIPLE_SCATTERING",
5604 0,
5605 "Multiple Scattering",
5606 "Multiple scattering sky model (more accurate)"},
5607 {SHD_SKY_PREETHAM, "PREETHAM", 0, "Preetham", "Preetham 1999 (Legacy)"},
5608 {SHD_SKY_HOSEK, "HOSEK_WILKIE", 0, "Hosek / Wilkie", "Hosek / Wilkie 2012 (Legacy)"},
5609 {0, nullptr, 0, nullptr, nullptr},
5610 };
5611
5612 PropertyRNA *prop;
5613
5614 RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
5615 def_sh_tex(brna, srna);
5616
5617 prop = RNA_def_property(srna, "sky_type", PROP_ENUM, PROP_NONE);
5618 RNA_def_property_enum_sdna(prop, nullptr, "sky_model");
5619 RNA_def_property_enum_items(prop, prop_sky_type);
5621 RNA_def_property_ui_text(prop, "Sky Type", "Which sky model should be used");
5622 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
5623
5624 /* Nishita parameters. */
5625 prop = RNA_def_property(srna, "sun_disc", PROP_BOOLEAN, PROP_NONE);
5626 RNA_def_property_ui_text(prop, "Sun Disc", "Include the sun itself in the output");
5627 RNA_def_property_boolean_sdna(prop, nullptr, "sun_disc", 1);
5629 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
5630
5631 prop = RNA_def_property(srna, "sun_size", PROP_FLOAT, PROP_ANGLE);
5632 RNA_def_property_ui_text(prop, "Sun Size", "Size of sun disc");
5633 RNA_def_property_range(prop, 0.0f, M_PI_2);
5635 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5636
5637 prop = RNA_def_property(srna, "sun_intensity", PROP_FLOAT, PROP_NONE);
5638 RNA_def_property_ui_text(prop, "Sun Intensity", "Strength of Sun");
5639 RNA_def_property_range(prop, 0.0f, 1000.0f);
5641 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5642
5643 prop = RNA_def_property(srna, "sun_elevation", PROP_FLOAT, PROP_ANGLE);
5644 RNA_def_property_ui_text(prop, "Sun Elevation", "Sun angle from horizon");
5646 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5647
5648 prop = RNA_def_property(srna, "sun_rotation", PROP_FLOAT, PROP_ANGLE);
5649 RNA_def_property_ui_text(prop, "Sun Rotation", "Rotation of sun around zenith");
5651 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5652
5653 prop = RNA_def_property(srna, "altitude", PROP_FLOAT, PROP_DISTANCE);
5654 RNA_def_property_ui_text(prop, "Altitude", "Height from sea level");
5655 RNA_def_property_range(prop, 0.0f, 100000.0f);
5656 RNA_def_property_ui_range(prop, 0.0f, 100000.0f, 10, 1);
5657 RNA_def_property_float_default(prop, 100.0f);
5658 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5659
5660 prop = RNA_def_property(srna, "air_density", PROP_FLOAT, PROP_NONE);
5662 "Air",
5663 "Density of air molecules.\n"
5664 "0 means no air, 1 means urban city air");
5665 RNA_def_property_range(prop, 0.0f, 1000.0f);
5667 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5668
5669 prop = RNA_def_property(srna, "aerosol_density", PROP_FLOAT, PROP_NONE);
5671 "Aerosols",
5672 "Density of dust, pollution and water droplets.\n"
5673 "0 means no aerosols, 1 means urban city aerosols");
5674 RNA_def_property_range(prop, 0.0f, 1000.0f);
5676 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5677
5678 prop = RNA_def_property(srna, "ozone_density", PROP_FLOAT, PROP_NONE);
5680 "Ozone",
5681 "Density of ozone layer.\n"
5682 "0 means no ozone, 1 means urban city ozone");
5683 RNA_def_property_range(prop, 0.0f, 1000.0f);
5685 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5686
5687 /* Legacy parameters. */
5688 prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
5689 RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
5690 RNA_def_property_array(prop, 3);
5691 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5692
5693 prop = RNA_def_property(srna, "turbidity", PROP_FLOAT, PROP_NONE);
5694 RNA_def_property_range(prop, 1.0f, 10.0f);
5696 RNA_def_property_ui_range(prop, 1.0f, 10.0f, 10, 3);
5697 RNA_def_property_ui_text(prop, "Turbidity", "Atmospheric turbidity");
5698 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5699
5700 prop = RNA_def_property(srna, "ground_albedo", PROP_FLOAT, PROP_FACTOR);
5701 RNA_def_property_range(prop, 0.0f, 1.0f);
5704 prop, "Ground Albedo", "Ground color that is subtly reflected in the sky");
5705 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
5706}
5707
5709 {SHD_INTERP_LINEAR, "Linear", 0, "Linear", "Linear interpolation"},
5710 {SHD_INTERP_CLOSEST, "Closest", 0, "Closest", "No interpolation (sample closest texel)"},
5711 {SHD_INTERP_CUBIC, "Cubic", 0, "Cubic", "Cubic interpolation"},
5712 {SHD_INTERP_SMART, "Smart", 0, "Smart", "Bicubic when magnifying, else bilinear (OSL only)"},
5713 {0, nullptr, 0, nullptr, nullptr},
5714};
5715
5717{
5718 static const EnumPropertyItem prop_projection_items[] = {
5720 "EQUIRECTANGULAR",
5721 0,
5722 "Equirectangular",
5723 "Equirectangular or latitude-longitude projection"},
5725 "MIRROR_BALL",
5726 0,
5727 "Mirror Ball",
5728 "Projection from an orthographic photo of a mirror ball"},
5729 {0, nullptr, 0, nullptr, nullptr},
5730 };
5731
5732 PropertyRNA *prop;
5733
5734 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
5735 RNA_def_property_pointer_sdna(prop, nullptr, "id");
5736 RNA_def_property_struct_type(prop, "Image");
5739 RNA_def_property_ui_text(prop, "Image", "");
5740 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
5742 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
5743
5744 RNA_def_struct_sdna_from(srna, "NodeTexEnvironment", "storage");
5745 def_sh_tex(brna, srna);
5746
5747 prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
5748 RNA_def_property_enum_items(prop, prop_projection_items);
5749 RNA_def_property_ui_text(prop, "Projection", "Projection of the input image");
5750 RNA_def_property_update(prop, 0, "rna_Node_update");
5751
5752 prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
5754 RNA_def_property_ui_text(prop, "Interpolation", "Texture interpolation");
5755 RNA_def_property_update(prop, 0, "rna_Node_update");
5756
5757 prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
5759 RNA_def_property_pointer_sdna(prop, nullptr, "iuser");
5761 prop,
5762 "Image User",
5763 "Parameters defining which layer, pass and frame of the image is displayed");
5764 RNA_def_property_update(prop, 0, "rna_Node_update");
5765}
5766
5767static void def_sh_tex_gabor(BlenderRNA *brna, StructRNA *srna)
5768{
5769 static const EnumPropertyItem prop_gabor_types[] = {
5771 "2D",
5772 0,
5773 "2D",
5774 "Use the 2D vector (X, Y) as input. The Z component is ignored."},
5775 {SHD_GABOR_TYPE_3D, "3D", 0, "3D", "Use the 3D vector (X, Y, Z) as input"},
5776 {0, nullptr, 0, nullptr, nullptr},
5777 };
5778
5779 RNA_def_struct_sdna_from(srna, "NodeTexGabor", "storage");
5780 def_sh_tex(brna, srna);
5781
5782 PropertyRNA *prop;
5783 prop = RNA_def_property(srna, "gabor_type", PROP_ENUM, PROP_NONE);
5784 RNA_def_property_enum_sdna(prop, nullptr, "type");
5785 RNA_def_property_enum_items(prop, prop_gabor_types);
5786 RNA_def_property_ui_text(prop, "Type", "The type of Gabor noise to evaluate");
5787 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
5788}
5789
5790static void def_sh_tex_image(BlenderRNA *brna, StructRNA *srna)
5791{
5792 static const EnumPropertyItem prop_projection_items[] = {
5794 "FLAT",
5795 0,
5796 "Flat",
5797 "Image is projected flat using the X and Y coordinates of the texture vector"},
5798 {SHD_PROJ_BOX,
5799 "BOX",
5800 0,
5801 "Box",
5802 "Image is projected using different components for each side of the object space bounding "
5803 "box"},
5805 "SPHERE",
5806 0,
5807 "Sphere",
5808 "Image is projected spherically using the Z axis as central"},
5810 "TUBE",
5811 0,
5812 "Tube",
5813 "Image is projected from the tube using the Z axis as central"},
5814 {0, nullptr, 0, nullptr, nullptr},
5815 };
5816
5817 PropertyRNA *prop;
5818
5819 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
5820 RNA_def_property_pointer_sdna(prop, nullptr, "id");
5821 RNA_def_property_struct_type(prop, "Image");
5824 RNA_def_property_ui_text(prop, "Image", "");
5825 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
5827 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
5828
5829 RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
5830 def_sh_tex(brna, srna);
5831
5832 prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
5833 RNA_def_property_enum_items(prop, prop_projection_items);
5835 prop, "Projection", "Method to project 2D image on object with a 3D texture vector");
5837 RNA_def_property_update(prop, 0, "rna_Node_update");
5838
5839 prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
5841 RNA_def_property_ui_text(prop, "Interpolation", "Texture interpolation");
5842 RNA_def_property_update(prop, 0, "rna_Node_update");
5843
5844 prop = RNA_def_property(srna, "projection_blend", PROP_FLOAT, PROP_FACTOR);
5846 prop, "Projection Blend", "For box projection, amount of blend to use between sides");
5847 RNA_def_property_update(prop, 0, "rna_Node_update");
5848
5849 prop = RNA_def_property(srna, "extension", PROP_ENUM, PROP_NONE);
5852 prop, "Extension", "How the image is extrapolated past its original bounds");
5854 RNA_def_property_update(prop, 0, "rna_Node_update");
5855
5856 prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
5858 RNA_def_property_pointer_sdna(prop, nullptr, "iuser");
5860 prop,
5861 "Image User",
5862 "Parameters defining which layer, pass and frame of the image is displayed");
5863 RNA_def_property_update(prop, 0, "rna_Node_update");
5864}
5865
5866static void def_tex_combsep_color(BlenderRNA * /*brna*/, StructRNA *srna)
5867{
5868 PropertyRNA *prop;
5869
5870 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
5871 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
5873 RNA_def_property_ui_text(prop, "Mode", "Mode of color processing");
5874 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
5875}
5876
5877static void def_geo_image_texture(BlenderRNA * /*brna*/, StructRNA *srna)
5878{
5879 static const EnumPropertyItem fn_tex_prop_interpolation_items[] = {
5880 {SHD_INTERP_LINEAR, "Linear", 0, "Linear", "Linear interpolation"},
5881 {SHD_INTERP_CLOSEST, "Closest", 0, "Closest", "No interpolation (sample closest texel)"},
5882 {SHD_INTERP_CUBIC, "Cubic", 0, "Cubic", "Cubic interpolation"},
5883 {0, nullptr, 0, nullptr, nullptr},
5884 };
5885
5886 PropertyRNA *prop;
5887
5888 RNA_def_struct_sdna_from(srna, "NodeGeometryImageTexture", "storage");
5889
5890 prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
5891 RNA_def_property_enum_items(prop, fn_tex_prop_interpolation_items);
5892 RNA_def_property_ui_text(prop, "Interpolation", "Method for smoothing values between pixels");
5893 RNA_def_property_update(prop, 0, "rna_Node_update");
5894
5895 prop = RNA_def_property(srna, "extension", PROP_ENUM, PROP_NONE);
5898 prop, "Extension", "How the image is extrapolated past its original bounds");
5900 RNA_def_property_update(prop, 0, "rna_Node_update");
5901}
5902
5904{
5905 PropertyRNA *prop;
5906
5907 RNA_def_struct_sdna_from(srna, "NodeGeometryTransformGizmo", "storage");
5908
5909 prop = RNA_def_property(srna, "use_translation_x", PROP_BOOLEAN, PROP_NONE);
5912 RNA_def_property_ui_text(prop, "Use Translation X", nullptr);
5913 RNA_def_property_update(prop, 0, "rna_Node_update");
5914
5915 prop = RNA_def_property(srna, "use_translation_y", PROP_BOOLEAN, PROP_NONE);
5918 RNA_def_property_ui_text(prop, "Use Translation Y", nullptr);
5919 RNA_def_property_update(prop, 0, "rna_Node_update");
5920
5921 prop = RNA_def_property(srna, "use_translation_z", PROP_BOOLEAN, PROP_NONE);
5924 RNA_def_property_ui_text(prop, "Use Translation Z", nullptr);
5925 RNA_def_property_update(prop, 0, "rna_Node_update");
5926
5927 prop = RNA_def_property(srna, "use_rotation_x", PROP_BOOLEAN, PROP_NONE);
5930 RNA_def_property_ui_text(prop, "Use Rotation X", nullptr);
5931 RNA_def_property_update(prop, 0, "rna_Node_update");
5932
5933 prop = RNA_def_property(srna, "use_rotation_y", PROP_BOOLEAN, PROP_NONE);
5936 RNA_def_property_ui_text(prop, "Use Rotation Y", nullptr);
5937 RNA_def_property_update(prop, 0, "rna_Node_update");
5938
5939 prop = RNA_def_property(srna, "use_rotation_z", PROP_BOOLEAN, PROP_NONE);
5942 RNA_def_property_ui_text(prop, "Use Rotation Z", nullptr);
5943 RNA_def_property_update(prop, 0, "rna_Node_update");
5944
5945 prop = RNA_def_property(srna, "use_scale_x", PROP_BOOLEAN, PROP_NONE);
5948 RNA_def_property_ui_text(prop, "Use Scale X", nullptr);
5949 RNA_def_property_update(prop, 0, "rna_Node_update");
5950
5951 prop = RNA_def_property(srna, "use_scale_y", PROP_BOOLEAN, PROP_NONE);
5954 RNA_def_property_ui_text(prop, "Use Scale Y", nullptr);
5955 RNA_def_property_update(prop, 0, "rna_Node_update");
5956
5957 prop = RNA_def_property(srna, "use_scale_z", PROP_BOOLEAN, PROP_NONE);
5960 RNA_def_property_ui_text(prop, "Use Scale Z", nullptr);
5961 RNA_def_property_update(prop, 0, "rna_Node_update");
5962}
5963
5965{
5966 static const EnumPropertyItem prop_gradient_type[] = {
5967 {SHD_BLEND_LINEAR, "LINEAR", 0, "Linear", "Create a linear progression"},
5968 {SHD_BLEND_QUADRATIC, "QUADRATIC", 0, "Quadratic", "Create a quadratic progression"},
5970 "EASING",
5971 0,
5972 "Easing",
5973 "Create a progression easing from one step to the next"},
5974 {SHD_BLEND_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Create a diagonal progression"},
5975 {SHD_BLEND_SPHERICAL, "SPHERICAL", 0, "Spherical", "Create a spherical progression"},
5977 "QUADRATIC_SPHERE",
5978 0,
5979 "Quadratic Sphere",
5980 "Create a quadratic progression in the shape of a sphere"},
5981 {SHD_BLEND_RADIAL, "RADIAL", 0, "Radial", "Create a radial progression"},
5982 {0, nullptr, 0, nullptr, nullptr},
5983 };
5984
5985 PropertyRNA *prop;
5986
5987 RNA_def_struct_sdna_from(srna, "NodeTexGradient", "storage");
5988 def_sh_tex(brna, srna);
5989
5990 prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
5991 RNA_def_property_enum_items(prop, prop_gradient_type);
5992 RNA_def_property_ui_text(prop, "Gradient Type", "Style of the color blending");
5993 RNA_def_property_update(prop, 0, "rna_Node_update");
5994}
5995
5996static void def_sh_tex_noise(BlenderRNA *brna, StructRNA *srna)
5997{
5998 static const EnumPropertyItem prop_noise_type[] = {
6000 "MULTIFRACTAL",
6001 0,
6002 "Multifractal",
6003 "More uneven result (varies with location), more similar to a real terrain"},
6005 "RIDGED_MULTIFRACTAL",
6006 0,
6007 "Ridged Multifractal",
6008 "Create sharp peaks"},
6010 "HYBRID_MULTIFRACTAL",
6011 0,
6012 "Hybrid Multifractal",
6013 "Create peaks and valleys with different roughness values"},
6014 {SHD_NOISE_FBM, "FBM", 0, "fBM", "The standard fractal Perlin noise"},
6016 "HETERO_TERRAIN",
6017 0,
6018 "Hetero Terrain",
6019 "Similar to Hybrid Multifractal creates a heterogeneous terrain, but with the likeness of "
6020 "river channels"},
6021 {0, nullptr, 0, nullptr, nullptr},
6022 };
6023
6024 PropertyRNA *prop;
6025
6026 RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
6027 def_sh_tex(brna, srna);
6028
6029 prop = RNA_def_property(srna, "noise_dimensions", PROP_ENUM, PROP_NONE);
6030 RNA_def_property_enum_sdna(prop, nullptr, "dimensions");
6032 RNA_def_property_ui_text(prop, "Dimensions", "Number of dimensions to output noise for");
6034 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
6035
6036 prop = RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE);
6037 RNA_def_property_enum_sdna(prop, nullptr, "type");
6038 RNA_def_property_enum_items(prop, prop_noise_type);
6040 RNA_def_property_ui_text(prop, "Type", "Type of the Noise texture");
6041 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
6042
6043 prop = RNA_def_property(srna, "normalize", PROP_BOOLEAN, PROP_NONE);
6044 RNA_def_property_boolean_sdna(prop, nullptr, "normalize", 0);
6046 RNA_def_property_ui_text(prop, "Normalize", "Normalize outputs to 0.0 to 1.0 range");
6047 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6048}
6049
6050static void def_sh_tex_checker(BlenderRNA *brna, StructRNA *srna)
6051{
6052 RNA_def_struct_sdna_from(srna, "NodeTexChecker", "storage");
6053 def_sh_tex(brna, srna);
6054}
6055
6056static void def_sh_tex_brick(BlenderRNA *brna, StructRNA *srna)
6057{
6058 PropertyRNA *prop;
6059
6060 RNA_def_struct_sdna_from(srna, "NodeTexBrick", "storage");
6061 def_sh_tex(brna, srna);
6062
6063 prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
6064 RNA_def_property_int_sdna(prop, nullptr, "offset_freq");
6066 RNA_def_property_range(prop, 1, 99);
6068 prop,
6069 "Offset Frequency",
6070 "How often rows are offset. A value of 2 gives an even/uneven pattern of rows.");
6071 RNA_def_property_update(prop, 0, "rna_Node_update");
6072
6073 prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
6074 RNA_def_property_int_sdna(prop, nullptr, "squash_freq");
6076 RNA_def_property_range(prop, 1, 99);
6078 prop, "Squash Frequency", "How often rows consist of \"squished\" bricks");
6079 RNA_def_property_update(prop, 0, "rna_Node_update");
6080
6081 prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
6082 RNA_def_property_float_sdna(prop, nullptr, "offset");
6084 RNA_def_property_range(prop, 0.0f, 1.0f);
6086 prop, "Offset Amount", "Determines the brick offset of the various rows");
6087 RNA_def_property_update(prop, 0, "rna_Node_update");
6088
6089 prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
6090 RNA_def_property_float_sdna(prop, nullptr, "squash");
6092 RNA_def_property_range(prop, 0.0f, 99.0f);
6094 prop,
6095 "Squash Amount",
6096 "Factor to adjust the brick's width for particular rows determined by the Offset Frequency");
6097 RNA_def_property_update(prop, 0, "rna_Node_update");
6098}
6099
6100static void def_sh_tex_magic(BlenderRNA *brna, StructRNA *srna)
6101{
6102 PropertyRNA *prop;
6103
6104 RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
6105 def_sh_tex(brna, srna);
6106
6107 prop = RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
6108 RNA_def_property_int_sdna(prop, nullptr, "depth");
6110 RNA_def_property_range(prop, 0, 10);
6111 RNA_def_property_ui_text(prop, "Depth", "Level of detail in the added turbulent noise");
6112 RNA_def_property_update(prop, 0, "rna_Node_update");
6113}
6114
6115static void def_sh_tex_voronoi(BlenderRNA *brna, StructRNA *srna)
6116{
6117 static EnumPropertyItem prop_distance_items[] = {
6118 {SHD_VORONOI_EUCLIDEAN, "EUCLIDEAN", 0, "Euclidean", "Euclidean distance"},
6119 {SHD_VORONOI_MANHATTAN, "MANHATTAN", 0, "Manhattan", "Manhattan distance"},
6120 {SHD_VORONOI_CHEBYCHEV, "CHEBYCHEV", 0, "Chebychev", "Chebychev distance"},
6121 {SHD_VORONOI_MINKOWSKI, "MINKOWSKI", 0, "Minkowski", "Minkowski distance"},
6122 {0, nullptr, 0, nullptr, nullptr}};
6123
6124 static EnumPropertyItem prop_feature_items[] = {
6126 "F1",
6127 0,
6128 "F1",
6129 "Computes the distance to the closest point as well as its position and color"},
6131 "F2",
6132 0,
6133 "F2",
6134 "Computes the distance to the second closest point as well as its position and color"},
6136 "SMOOTH_F1",
6137 0,
6138 "Smooth F1",
6139 "Smoothed version of F1. Weighted sum of neighbor voronoi cells."},
6141 "DISTANCE_TO_EDGE",
6142 0,
6143 "Distance to Edge",
6144 "Computes the distance to the edge of the voronoi cell"},
6146 "N_SPHERE_RADIUS",
6147 0,
6148 "N-Sphere Radius",
6149 "Computes the radius of the n-sphere inscribed in the voronoi cell"},
6150 {0, nullptr, 0, nullptr, nullptr}};
6151
6152 PropertyRNA *prop;
6153
6154 RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
6155 def_sh_tex(brna, srna);
6156
6157 prop = RNA_def_property(srna, "voronoi_dimensions", PROP_ENUM, PROP_NONE);
6158 RNA_def_property_enum_sdna(prop, nullptr, "dimensions");
6160 RNA_def_property_ui_text(prop, "Dimensions", "Number of dimensions to output noise for");
6162 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
6163
6164 prop = RNA_def_property(srna, "distance", PROP_ENUM, PROP_NONE);
6165 RNA_def_property_enum_sdna(prop, nullptr, "distance");
6166 RNA_def_property_enum_items(prop, prop_distance_items);
6168 prop, "Distance Metric", "The distance metric used to compute the texture");
6169 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
6170
6171 prop = RNA_def_property(srna, "feature", PROP_ENUM, PROP_NONE);
6172 RNA_def_property_enum_sdna(prop, nullptr, "feature");
6173 RNA_def_property_enum_items(prop, prop_feature_items);
6175 prop, "Feature Output", "The Voronoi feature that the node will compute");
6176 RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
6177
6178 prop = RNA_def_property(srna, "normalize", PROP_BOOLEAN, PROP_NONE);
6179 RNA_def_property_boolean_sdna(prop, nullptr, "normalize", 0);
6180 RNA_def_property_ui_text(prop, "Normalize", "Normalize output Distance to 0.0 to 1.0 range");
6181 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6182}
6183
6184static void def_sh_tex_wave(BlenderRNA *brna, StructRNA *srna)
6185{
6186 static const EnumPropertyItem prop_wave_type_items[] = {
6187 {SHD_WAVE_BANDS, "BANDS", 0, "Bands", "Use standard wave texture in bands"},
6188 {SHD_WAVE_RINGS, "RINGS", 0, "Rings", "Use wave texture in rings"},
6189 {0, nullptr, 0, nullptr, nullptr},
6190 };
6191
6192 static EnumPropertyItem prop_wave_bands_direction_items[] = {
6193 {SHD_WAVE_BANDS_DIRECTION_X, "X", 0, "X", "Bands across X axis"},
6194 {SHD_WAVE_BANDS_DIRECTION_Y, "Y", 0, "Y", "Bands across Y axis"},
6195 {SHD_WAVE_BANDS_DIRECTION_Z, "Z", 0, "Z", "Bands across Z axis"},
6196 {SHD_WAVE_BANDS_DIRECTION_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Bands across diagonal axis"},
6197 {0, nullptr, 0, nullptr, nullptr},
6198 };
6199
6200 static EnumPropertyItem prop_wave_rings_direction_items[] = {
6201 {SHD_WAVE_RINGS_DIRECTION_X, "X", 0, "X", "Rings along X axis"},
6202 {SHD_WAVE_RINGS_DIRECTION_Y, "Y", 0, "Y", "Rings along Y axis"},
6203 {SHD_WAVE_RINGS_DIRECTION_Z, "Z", 0, "Z", "Rings along Z axis"},
6205 "SPHERICAL",
6206 0,
6207 "Spherical",
6208 "Rings along spherical distance"},
6209 {0, nullptr, 0, nullptr, nullptr},
6210 };
6211
6212 static const EnumPropertyItem prop_wave_profile_items[] = {
6213 {SHD_WAVE_PROFILE_SIN, "SIN", 0, "Sine", "Use a standard sine profile"},
6214 {SHD_WAVE_PROFILE_SAW, "SAW", 0, "Saw", "Use a sawtooth profile"},
6215 {SHD_WAVE_PROFILE_TRI, "TRI", 0, "Triangle", "Use a triangle profile"},
6216 {0, nullptr, 0, nullptr, nullptr},
6217 };
6218
6219 PropertyRNA *prop;
6220
6221 RNA_def_struct_sdna_from(srna, "NodeTexWave", "storage");
6222 def_sh_tex(brna, srna);
6223
6224 prop = RNA_def_property(srna, "wave_type", PROP_ENUM, PROP_NONE);
6225 RNA_def_property_enum_sdna(prop, nullptr, "wave_type");
6226 RNA_def_property_enum_items(prop, prop_wave_type_items);
6227 RNA_def_property_ui_text(prop, "Wave Type", "");
6228 RNA_def_property_update(prop, 0, "rna_Node_update");
6229
6230 prop = RNA_def_property(srna, "bands_direction", PROP_ENUM, PROP_NONE);
6231 RNA_def_property_enum_sdna(prop, nullptr, "bands_direction");
6232 RNA_def_property_enum_items(prop, prop_wave_bands_direction_items);
6233 RNA_def_property_ui_text(prop, "Bands Direction", "");
6234 RNA_def_property_update(prop, 0, "rna_Node_update");
6235
6236 prop = RNA_def_property(srna, "rings_direction", PROP_ENUM, PROP_NONE);
6237 RNA_def_property_enum_sdna(prop, nullptr, "rings_direction");
6238 RNA_def_property_enum_items(prop, prop_wave_rings_direction_items);
6239 RNA_def_property_ui_text(prop, "Rings Direction", "");
6240 RNA_def_property_update(prop, 0, "rna_Node_update");
6241
6242 prop = RNA_def_property(srna, "wave_profile", PROP_ENUM, PROP_NONE);
6243 RNA_def_property_enum_sdna(prop, nullptr, "wave_profile");
6244 RNA_def_property_enum_items(prop, prop_wave_profile_items);
6245 RNA_def_property_ui_text(prop, "Wave Profile", "");
6246 RNA_def_property_update(prop, 0, "rna_Node_update");
6247}
6248
6249static void def_sh_tex_white_noise(BlenderRNA * /*brna*/, StructRNA *srna)
6250{
6251 PropertyRNA *prop;
6252
6253 prop = RNA_def_property(srna, "noise_dimensions", PROP_ENUM, PROP_NONE);
6254 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6256 RNA_def_property_ui_text(prop, "Dimensions", "Number of dimensions to output noise for");
6258 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6259}
6260
6261static void def_sh_tex_coord(BlenderRNA * /*brna*/, StructRNA *srna)
6262{
6263 PropertyRNA *prop;
6264
6265 prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
6266 RNA_def_property_pointer_sdna(prop, nullptr, "id");
6267 RNA_def_property_struct_type(prop, "Object");
6271 prop, "Object", "Use coordinates from this object (for object texture coordinates output)");
6272 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
6273
6274 prop = RNA_def_property(srna, "from_instancer", PROP_BOOLEAN, PROP_NONE);
6275 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
6277 prop, "From Instancer", "Use the parent of the instance object if possible");
6278 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6279}
6280
6281static void def_sh_vect_transform(BlenderRNA * /*brna*/, StructRNA *srna)
6282{
6283 static const EnumPropertyItem prop_vect_type_items[] = {
6284 {SHD_VECT_TRANSFORM_TYPE_POINT, "POINT", 0, "Point", "Transform a point"},
6285 {SHD_VECT_TRANSFORM_TYPE_VECTOR, "VECTOR", 0, "Vector", "Transform a direction vector"},
6287 "NORMAL",
6288 0,
6289 "Normal",
6290 "Transform a normal vector with unit length"},
6291 {0, nullptr, 0, nullptr, nullptr},
6292 };
6293
6294 PropertyRNA *prop;
6295
6296 RNA_def_struct_sdna_from(srna, "NodeShaderVectTransform", "storage");
6297
6298 prop = RNA_def_property(srna, "vector_type", PROP_ENUM, PROP_NONE);
6299 RNA_def_property_enum_sdna(prop, nullptr, "type");
6300 RNA_def_property_enum_items(prop, prop_vect_type_items);
6301 RNA_def_property_ui_text(prop, "Type", "");
6302 RNA_def_property_update(prop, 0, "rna_Node_update");
6303
6304 prop = RNA_def_property(srna, "convert_from", PROP_ENUM, PROP_NONE);
6306 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeShaderVectTransform_space_itemf");
6307 RNA_def_property_ui_text(prop, "Convert From", "Space to convert from");
6308 RNA_def_property_update(prop, 0, "rna_Node_update");
6309
6310 prop = RNA_def_property(srna, "convert_to", PROP_ENUM, PROP_NONE);
6313 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeShaderVectTransform_space_itemf");
6314 RNA_def_property_ui_text(prop, "Convert To", "Space to convert to");
6315 RNA_def_property_update(prop, 0, "rna_Node_update");
6316}
6317
6318static void def_sh_tex_wireframe(BlenderRNA * /*brna*/, StructRNA *srna)
6319{
6320 PropertyRNA *prop;
6321
6322 prop = RNA_def_property(srna, "use_pixel_size", PROP_BOOLEAN, PROP_NONE);
6323 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
6324 RNA_def_property_ui_text(prop, "Pixel Size", "Use screen pixel size instead of world units");
6326 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6327}
6328
6329static void def_metallic(BlenderRNA * /*brna*/, StructRNA *srna)
6330{
6331 PropertyRNA *prop;
6332
6333 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6334 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6337 RNA_def_property_ui_text(prop, "Distribution", "Light scattering distribution on rough surface");
6338 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6339
6340 prop = RNA_def_property(srna, "fresnel_type", PROP_ENUM, PROP_NONE);
6341 RNA_def_property_enum_sdna(prop, nullptr, "custom2");
6344 RNA_def_property_ui_text(prop, "Fresnel Type", "Fresnel method used to tint the metal");
6345 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6346}
6347
6348static void def_glossy(BlenderRNA * /*brna*/, StructRNA *srna)
6349{
6350 PropertyRNA *prop;
6351
6352 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6353 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6356 RNA_def_property_ui_text(prop, "Distribution", "Light scattering distribution on rough surface");
6357 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6358}
6359
6360static void def_glass(BlenderRNA * /*brna*/, StructRNA *srna)
6361{
6362 PropertyRNA *prop;
6363
6364 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6365 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6368 RNA_def_property_ui_text(prop, "Distribution", "Light scattering distribution on rough surface");
6369 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6370}
6371
6372static void def_sheen(BlenderRNA * /*brna*/, StructRNA *srna)
6373{
6374 PropertyRNA *prop;
6375
6376 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6377 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6380 RNA_def_property_ui_text(prop, "Distribution", "Sheen shading model");
6381 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6382}
6383
6384static void def_principled(BlenderRNA * /*brna*/, StructRNA *srna)
6385{
6386 PropertyRNA *prop;
6387
6388 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6389 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6392 RNA_def_property_ui_text(prop, "Distribution", "Light scattering distribution on rough surface");
6393 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6394
6395 prop = RNA_def_property(srna, "subsurface_method", PROP_ENUM, PROP_NONE);
6396 RNA_def_property_enum_sdna(prop, nullptr, "custom2");
6400 prop, "Subsurface Method", "Method for rendering subsurface scattering");
6401 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6402}
6403
6404static void def_light_evaluation(BlenderRNA * /*brna*/, StructRNA *srna)
6405{
6406 PropertyRNA *prop;
6407
6408 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
6409 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6411 RNA_def_property_ui_text(prop, "Mode", "Defines parametrization of the light evaluation");
6412 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6413}
6414
6415static void def_refraction(BlenderRNA * /*brna*/, StructRNA *srna)
6416{
6417 PropertyRNA *prop;
6418
6419 prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
6420 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6422 RNA_def_property_ui_text(prop, "Distribution", "Light scattering distribution on rough surface");
6423 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6424}
6425
6426static void def_scatter(BlenderRNA * /*brna*/, StructRNA *srna)
6427{
6428 PropertyRNA *prop;
6429
6430 prop = RNA_def_property(srna, "phase", PROP_ENUM, PROP_NONE);
6431 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6433 RNA_def_property_ui_text(prop, "Phase", "Phase function for the scattered light");
6434 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6435}
6436
6437static void def_volume_coefficients(BlenderRNA * /*brna*/, StructRNA *srna)
6438{
6439 PropertyRNA *prop;
6440
6441 prop = RNA_def_property(srna, "phase", PROP_ENUM, PROP_NONE);
6442 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6444 RNA_def_property_ui_text(prop, "Phase", "Phase function for the scattered light");
6445 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6446}
6447
6448static void def_toon(BlenderRNA * /*brna*/, StructRNA *srna)
6449{
6450 PropertyRNA *prop;
6451
6452 prop = RNA_def_property(srna, "component", PROP_ENUM, PROP_NONE);
6453 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6455 RNA_def_property_ui_text(prop, "Component", "Toon BSDF component to use");
6456 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6457}
6458
6459static void def_sh_bump(BlenderRNA * /*brna*/, StructRNA *srna)
6460{
6461 PropertyRNA *prop;
6462
6463 prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
6464 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
6466 prop, "Invert", "Invert the bump mapping direction to push into the surface instead of out");
6467 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6468}
6469
6470static void def_hair(BlenderRNA * /*brna*/, StructRNA *srna)
6471{
6472 PropertyRNA *prop;
6473
6474 prop = RNA_def_property(srna, "component", PROP_ENUM, PROP_NONE);
6475 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6477 RNA_def_property_ui_text(prop, "Component", "Hair BSDF component to use");
6478 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6479}
6480
6481/* RNA initialization for the custom properties. */
6482static void def_hair_principled(BlenderRNA * /*brna*/, StructRNA *srna)
6483{
6484 PropertyRNA *prop;
6485
6486 RNA_def_struct_sdna_from(srna, "NodeShaderHairPrincipled", "storage");
6487
6488 prop = RNA_def_property(srna, "model", PROP_ENUM, PROP_NONE);
6489 RNA_def_property_enum_sdna(prop, nullptr, "model");
6490 RNA_def_property_ui_text(prop, "Scattering model", "Select from Chiang or Huang model");
6493 /* Upon editing, update both the node data AND the UI representation */
6494 /* (This effectively shows/hides the relevant sockets) */
6495 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6496
6497 prop = RNA_def_property(srna, "parametrization", PROP_ENUM, PROP_NONE);
6498 RNA_def_property_enum_sdna(prop, nullptr, "parametrization");
6500 prop, "Color Parametrization", "Select the shader's color parametrization");
6503 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6504}
6505
6506static void def_sh_uvmap(BlenderRNA * /*brna*/, StructRNA *srna)
6507{
6508 PropertyRNA *prop;
6509
6510 prop = RNA_def_property(srna, "from_instancer", PROP_BOOLEAN, PROP_NONE);
6511 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
6513 prop, "From Instancer", "Use the parent of the instance object if possible");
6514 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6515
6516 RNA_def_struct_sdna_from(srna, "NodeShaderUVMap", "storage");
6517
6518 prop = RNA_def_property(srna, "uv_map", PROP_STRING, PROP_NONE);
6519 RNA_def_property_ui_text(prop, "UV Map", "UV coordinates to be used for mapping");
6520 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6521
6522 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6523}
6524
6525static void def_sh_vertex_color(BlenderRNA * /*brna*/, StructRNA *srna)
6526{
6527 PropertyRNA *prop;
6528
6529 RNA_def_struct_sdna_from(srna, "NodeShaderVertexColor", "storage");
6530
6531 prop = RNA_def_property(srna, "layer_name", PROP_STRING, PROP_NONE);
6532 RNA_def_property_ui_text(prop, "Color Attribute", "Color Attribute");
6533 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6534
6535 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6536}
6537
6538static void def_sh_uvalongstroke(BlenderRNA * /*brna*/, StructRNA *srna)
6539{
6540 PropertyRNA *prop;
6541
6542 prop = RNA_def_property(srna, "use_tips", PROP_BOOLEAN, PROP_NONE);
6543 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
6545 prop, "Use Tips", "Lower half of the texture is for tips of the stroke");
6546 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6547}
6548
6549static void def_sh_normal_map(BlenderRNA * /*brna*/, StructRNA *srna)
6550{
6551 static const EnumPropertyItem prop_space_items[] = {
6552 {SHD_SPACE_TANGENT, "TANGENT", 0, "Tangent Space", "Tangent space normal mapping"},
6553 {SHD_SPACE_OBJECT, "OBJECT", 0, "Object Space", "Object space normal mapping"},
6554 {SHD_SPACE_WORLD, "WORLD", 0, "World Space", "World space normal mapping"},
6556 "BLENDER_OBJECT",
6557 0,
6558 "Blender Object Space",
6559 "Object space normal mapping, compatible with Blender render baking"},
6561 "BLENDER_WORLD",
6562 0,
6563 "Blender World Space",
6564 "World space normal mapping, compatible with Blender render baking"},
6565 {0, nullptr, 0, nullptr, nullptr},
6566 };
6567
6568 static const EnumPropertyItem prop_convention_items[] = {
6570 "OPENGL",
6571 0,
6572 "OpenGL",
6573 "Normal map uses OpenGL convention, with Y axis in the green channel pointing up"},
6575 "DIRECTX",
6576 0,
6577 "DirectX",
6578 "Normal map uses DirectX convention, with Y axis in the green channel pointing down"},
6579 {0, nullptr, 0, nullptr, nullptr},
6580 };
6581
6582 PropertyRNA *prop;
6583
6584 RNA_def_struct_sdna_from(srna, "NodeShaderNormalMap", "storage");
6585
6586 prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
6587 RNA_def_property_enum_items(prop, prop_space_items);
6588 RNA_def_property_ui_text(prop, "Space", "Space of the input normal");
6589 RNA_def_property_update(prop, 0, "rna_Node_update");
6590
6591 prop = RNA_def_property(srna, "uv_map", PROP_STRING, PROP_NONE);
6592 RNA_def_property_ui_text(prop, "UV Map", "UV Map for tangent space maps");
6593 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6594
6595 prop = RNA_def_property(srna, "convention", PROP_ENUM, PROP_NONE);
6596 RNA_def_property_enum_items(prop, prop_convention_items);
6597 RNA_def_property_ui_text(prop, "Mode", "OpenGL or DirectX");
6598 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6599
6600 static const EnumPropertyItem prop_base_items[] = {
6602 "ORIGINAL",
6603 0,
6604 "Original Base",
6605 "Apply normal map relative to the smooth undisplaced surface, for normal maps that match "
6606 "the displacement map"},
6608 "DISPLACED",
6609 0,
6610 "Displaced Base",
6611 "Apply normal map relative to the displaced surface, for normal maps that are to be "
6612 "applied in addition to the displacement map"},
6613 {0, nullptr, 0, nullptr, nullptr},
6614 };
6615
6616 prop = RNA_def_property(srna, "base", PROP_ENUM, PROP_NONE);
6617 RNA_def_property_enum_items(prop, prop_base_items);
6619 prop,
6620 "Base",
6621 "Base surface that the normal map is applied relative to, when displacement is used");
6622 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6623
6624 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6625}
6626
6627static void def_sh_radial_tiling(BlenderRNA * /*brna*/, StructRNA *srna)
6628{
6629 PropertyRNA *prop;
6630
6631 RNA_def_struct_sdna_from(srna, "NodeRadialTiling", "storage");
6632
6633 prop = RNA_def_property(srna, "normalize", PROP_BOOLEAN, PROP_NONE);
6634 RNA_def_property_boolean_sdna(prop, nullptr, "normalize", 0);
6636 prop,
6637 "Normalize",
6638 "Normalize the X coordinate of the Segment Coordinates output to a [0, 1] interval and "
6639 "offset the Y coordinate into a [0, infinity) interval. When checked, the textures are "
6640 "stretched to fit into each angular segment. When not checked, the parts of the textures "
6641 "that don't fit into each angular segment are cropped");
6642 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6643}
6644
6646{
6647 StructRNA *srna = RNA_def_struct(brna, "NodeRaycastSampleAttributeItem", nullptr);
6648 RNA_def_struct_ui_text(srna, "Raycast Sample Attribute Item", "");
6649 RNA_def_struct_sdna(srna, "NodeRaycastSampleAttributeItem");
6650
6651 rna_def_node_item_array_socket_item_common(srna, "RaycastSampleAttributeItemsAccessor", false);
6652 PropertyRNA *prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
6655 prop, nullptr, nullptr, "rna_NodeRaycastSampleAttributeItem_data_type_itemf");
6656 RNA_def_property_ui_text(prop, "Data Type", "");
6660 "rna_Node_ItemArray_item_update<RaycastSampleAttributeItemsAccessor>");
6661}
6662
6664{
6665 StructRNA *srna = RNA_def_struct(brna, "NodeRaycastSampleAttributeItems", nullptr);
6666 RNA_def_struct_ui_text(srna, "Items", "Collection of capture attribute items");
6667 RNA_def_struct_sdna(srna, "bNode");
6668
6670 srna, "NodeRaycastSampleAttributeItem", "RaycastSampleAttributeItemsAccessor");
6672 srna, "NodeRaycastSampleAttributeItem", "RaycastSampleAttributeItemsAccessor");
6673}
6674
6675static void def_sh_raycast(BlenderRNA *brna, StructRNA *srna)
6676{
6679
6680 PropertyRNA *prop = RNA_def_property(srna, "only_local", PROP_BOOLEAN, PROP_NONE);
6681 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 0);
6682 RNA_def_property_ui_text(prop, "Only Local", "Only raycast against the object itself");
6683 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6684
6685 RNA_def_struct_sdna_from(srna, "NodeShaderRaycast", "storage");
6686
6687 prop = RNA_def_property(srna, "sample_attribute_items", PROP_COLLECTION, PROP_NONE);
6689 prop, nullptr, "sample_attribute_items", "sample_attribute_items_num");
6690 RNA_def_property_struct_type(prop, "NodeRaycastSampleAttributeItem");
6691 RNA_def_property_ui_text(prop, "Items", "");
6692 RNA_def_property_srna(prop, "NodeRaycastSampleAttributeItems");
6693
6694 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
6695 RNA_def_property_int_sdna(prop, nullptr, "active_index");
6696 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
6699 RNA_def_property_update(prop, NC_NODE, nullptr);
6700
6701 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
6702 RNA_def_property_struct_type(prop, "RepeatItem");
6704 prop,
6705 "rna_Node_ItemArray_active_get<RaycastSampleAttributeItemsAccessor>",
6706 "rna_Node_ItemArray_active_set<RaycastSampleAttributeItemsAccessor>",
6707 nullptr,
6708 nullptr);
6710 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
6711 RNA_def_property_update(prop, NC_NODE, nullptr);
6712}
6713
6714static void def_sh_displacement(BlenderRNA * /*brna*/, StructRNA *srna)
6715{
6716 static const EnumPropertyItem prop_space_items[] = {
6718 "OBJECT",
6719 0,
6720 "Object Space",
6721 "Displacement is in object space, affected by object scale"},
6723 "WORLD",
6724 0,
6725 "World Space",
6726 "Displacement is in world space, not affected by object scale"},
6727 {0, nullptr, 0, nullptr, nullptr},
6728 };
6729
6730 PropertyRNA *prop;
6731
6732 prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
6733 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6734 RNA_def_property_enum_items(prop, prop_space_items);
6735 RNA_def_property_ui_text(prop, "Space", "Space of the input height");
6736 RNA_def_property_update(prop, 0, "rna_Node_update");
6737
6738 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6739}
6740
6742{
6743 static const EnumPropertyItem prop_space_items[] = {
6745 "TANGENT",
6746 0,
6747 "Tangent Space",
6748 "Tangent space vector displacement mapping"},
6749 {SHD_SPACE_OBJECT, "OBJECT", 0, "Object Space", "Object space vector displacement mapping"},
6750 {SHD_SPACE_WORLD, "WORLD", 0, "World Space", "World space vector displacement mapping"},
6751 {0, nullptr, 0, nullptr, nullptr},
6752 };
6753
6754 PropertyRNA *prop;
6755
6756 prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
6757 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6758 RNA_def_property_enum_items(prop, prop_space_items);
6759 RNA_def_property_ui_text(prop, "Space", "Space of the input height");
6760 RNA_def_property_update(prop, 0, "rna_Node_update");
6761
6762 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6763}
6764
6765static void def_sh_tangent(BlenderRNA * /*brna*/, StructRNA *srna)
6766{
6767 static const EnumPropertyItem prop_direction_type_items[] = {
6768 {SHD_TANGENT_RADIAL, "RADIAL", 0, "Radial", "Radial tangent around the X, Y or Z axis"},
6769 {SHD_TANGENT_UVMAP, "UV_MAP", 0, "UV Map", "Tangent from UV map"},
6770 {0, nullptr, 0, nullptr, nullptr},
6771 };
6772
6773 static const EnumPropertyItem prop_axis_items[] = {
6774 {SHD_TANGENT_AXIS_X, "X", 0, "X", "X axis"},
6775 {SHD_TANGENT_AXIS_Y, "Y", 0, "Y", "Y axis"},
6776 {SHD_TANGENT_AXIS_Z, "Z", 0, "Z", "Z axis"},
6777 {0, nullptr, 0, nullptr, nullptr},
6778 };
6779
6780 PropertyRNA *prop;
6781
6782 RNA_def_struct_sdna_from(srna, "NodeShaderTangent", "storage");
6783
6784 prop = RNA_def_property(srna, "direction_type", PROP_ENUM, PROP_NONE);
6785 RNA_def_property_enum_items(prop, prop_direction_type_items);
6786 RNA_def_property_ui_text(prop, "Direction", "Method to use for the tangent");
6787 RNA_def_property_update(prop, 0, "rna_Node_update");
6788
6789 prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
6790 RNA_def_property_enum_items(prop, prop_axis_items);
6792 RNA_def_property_ui_text(prop, "Axis", "Axis for radial tangents");
6793 RNA_def_property_update(prop, 0, "rna_Node_update");
6794
6795 prop = RNA_def_property(srna, "uv_map", PROP_STRING, PROP_NONE);
6796 RNA_def_property_ui_text(prop, "UV Map", "UV Map for tangent generated from UV");
6797 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6798
6799 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6800}
6801
6802static void def_sh_bevel(BlenderRNA * /*brna*/, StructRNA *srna)
6803{
6804 PropertyRNA *prop;
6805
6806 prop = RNA_def_property(srna, "samples", PROP_INT, PROP_UNSIGNED);
6807 RNA_def_property_int_sdna(prop, nullptr, "custom1");
6808 RNA_def_property_range(prop, 2, 128);
6809 RNA_def_property_ui_range(prop, 2, 16, 1, 1);
6811 RNA_def_property_ui_text(prop, "Samples", "Number of rays to trace per shader evaluation");
6812 RNA_def_property_update(prop, 0, "rna_Node_update");
6813}
6814
6815static void def_sh_ambient_occlusion(BlenderRNA * /*brna*/, StructRNA *srna)
6816{
6817 PropertyRNA *prop;
6818
6819 prop = RNA_def_property(srna, "samples", PROP_INT, PROP_UNSIGNED);
6820 RNA_def_property_int_sdna(prop, nullptr, "custom1");
6821 RNA_def_property_range(prop, 1, 128);
6823 RNA_def_property_ui_text(prop, "Samples", "Number of rays to trace per shader evaluation");
6824 RNA_def_property_update(prop, 0, "rna_Node_update");
6825
6826 prop = RNA_def_property(srna, "inside", PROP_BOOLEAN, PROP_NONE);
6827 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", SHD_AO_INSIDE);
6828 RNA_def_property_ui_text(prop, "Inside", "Trace rays towards the inside of the object");
6829 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6830
6831 prop = RNA_def_property(srna, "only_local", PROP_BOOLEAN, PROP_NONE);
6832 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", SHD_AO_LOCAL);
6834 prop, "Only Local", "Only consider the object itself when computing AO");
6835 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6836}
6837
6838static void def_sh_subsurface(BlenderRNA * /*brna*/, StructRNA *srna)
6839{
6840 PropertyRNA *prop;
6841
6842 prop = RNA_def_property(srna, "falloff", PROP_ENUM, PROP_NONE);
6843 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
6846 RNA_def_property_ui_text(prop, "Method", "Method for rendering subsurface scattering");
6847 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update");
6848}
6849
6850static void def_sh_tex_ies(BlenderRNA * /*brna*/, StructRNA *srna)
6851{
6852 PropertyRNA *prop;
6853
6854 prop = RNA_def_property(srna, "ies", PROP_POINTER, PROP_NONE);
6855 RNA_def_property_pointer_sdna(prop, nullptr, "id");
6856 RNA_def_property_struct_type(prop, "Text");
6859 RNA_def_property_ui_text(prop, "IES Text", "Internal IES file");
6860 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6861
6862 RNA_def_struct_sdna_from(srna, "NodeShaderTexIES", "storage");
6863
6864 prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
6865 RNA_def_property_ui_text(prop, "File Path", "IES light path");
6867 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6868
6869 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
6870 RNA_def_property_enum_funcs(prop, nullptr, "rna_ShaderNodeTexIES_mode_set", nullptr);
6873 prop, "Source", "Whether the IES file is loaded from disk or from a text data-block");
6874 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6875
6876 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6877}
6878
6879static void def_sh_output_aov(BlenderRNA * /*brna*/, StructRNA *srna)
6880{
6881 PropertyRNA *prop;
6882
6883 RNA_def_struct_sdna_from(srna, "NodeShaderOutputAOV", "storage");
6884
6885 prop = RNA_def_property(srna, "aov_name", PROP_STRING, PROP_NONE);
6886 RNA_def_property_string_sdna(prop, nullptr, "name");
6887 RNA_def_property_ui_text(prop, "Name", "Name of the AOV that this output writes to");
6888 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6889
6890 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6891}
6892
6893static void def_sh_combsep_color(BlenderRNA * /*brna*/, StructRNA *srna)
6894{
6895 PropertyRNA *prop;
6896
6897 RNA_def_struct_sdna_from(srna, "NodeCombSepColor", "storage");
6898
6899 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
6901 RNA_def_property_ui_text(prop, "Mode", "Mode of color processing");
6902 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
6903}
6904
6905static void def_sh_script(BlenderRNA * /*brna*/, StructRNA *srna)
6906{
6907 PropertyRNA *prop;
6908
6909 prop = RNA_def_property(srna, "script", PROP_POINTER, PROP_NONE);
6910 RNA_def_property_pointer_sdna(prop, nullptr, "id");
6911 RNA_def_property_struct_type(prop, "Text");
6914 RNA_def_property_ui_text(prop, "Script", "Internal shader script to define the shader");
6915 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update");
6916
6917 RNA_def_struct_sdna_from(srna, "NodeShaderScript", "storage");
6918
6919 prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
6920 RNA_def_property_ui_text(prop, "File Path", "Shader script path");
6922 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update");
6923
6924 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
6925 RNA_def_property_enum_funcs(prop, nullptr, "rna_ShaderNodeScript_mode_set", nullptr);
6927 RNA_def_property_ui_text(prop, "Script Source", "");
6928 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6929
6930 prop = RNA_def_property(srna, "use_auto_update", PROP_BOOLEAN, PROP_NONE);
6933 prop,
6934 "Auto Update",
6935 "Automatically update the shader when the .osl file changes (external scripts only)");
6936
6937 prop = RNA_def_property(srna, "bytecode", PROP_STRING, PROP_NONE);
6939 "rna_ShaderNodeScript_bytecode_get",
6940 "rna_ShaderNodeScript_bytecode_length",
6941 "rna_ShaderNodeScript_bytecode_set");
6942 RNA_def_property_ui_text(prop, "Bytecode", "Compile bytecode for shader script node");
6943 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6944
6945 prop = RNA_def_property(srna, "bytecode_hash", PROP_STRING, PROP_NONE);
6947 prop, "Bytecode Hash", "Hash of compile bytecode, for quick equality checking");
6948 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6949
6950 /* needs to be reset to avoid bad pointer type in API functions below */
6951 RNA_def_struct_sdna_from(srna, "bNode", nullptr);
6952
6953 /* API functions */
6954
6955# if 0 /* XXX TODO: use general node API for this. */
6956 func = RNA_def_function(srna, "find_socket", "rna_ShaderNodeScript_find_socket");
6957 RNA_def_function_ui_description(func, "Find a socket by name");
6958 parm = RNA_def_string(func, "name", nullptr, 0, "Socket name", "");
6960 /*parm =*/RNA_def_boolean(func, "is_output", false, "Output", "Whether the socket is an output");
6961 parm = RNA_def_pointer(func, "result", "NodeSocket", "", "");
6962 RNA_def_function_return(func, parm);
6963
6964 func = RNA_def_function(srna, "add_socket", "rna_ShaderNodeScript_add_socket");
6965 RNA_def_function_ui_description(func, "Add a socket");
6967 parm = RNA_def_string(func, "name", nullptr, 0, "Name", "");
6969 parm = RNA_def_enum(func, "type", rna_enum_node_socket_type_items, SOCK_FLOAT, "Type", "");
6971 /*parm =*/RNA_def_boolean(func, "is_output", false, "Output", "Whether the socket is an output");
6972 parm = RNA_def_pointer(func, "result", "NodeSocket", "", "");
6973 RNA_def_function_return(func, parm);
6974
6975 func = RNA_def_function(srna, "remove_socket", "rna_ShaderNodeScript_remove_socket");
6976 RNA_def_function_ui_description(func, "Remove a socket");
6978 parm = RNA_def_pointer(func, "sock", "NodeSocket", "Socket", "");
6980# endif
6981}
6982
6983/* -- Compositor Nodes ------------------------------------------------------ */
6984
6985static void def_node_image_user(BlenderRNA * /*brna*/, StructRNA *srna)
6986{
6987 PropertyRNA *prop;
6988
6989 prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
6990 RNA_def_property_int_sdna(prop, nullptr, "frames");
6993 prop, "Frames", "Number of images of a movie to use"); /* copied from the rna_image.cc */
6994 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
6995
6996 prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
6997 RNA_def_property_int_sdna(prop, nullptr, "sfra");
6999 /* copied from the rna_image.cc */
7001 prop,
7002 "Start Frame",
7003 "Global starting frame of the movie/sequence, assuming first picture has a #1");
7004 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7005
7006 prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
7007 RNA_def_property_int_sdna(prop, nullptr, "offset");
7009 /* copied from the rna_image.cc */
7011 prop, "Offset", "Offset the number of the frame to use in the animation");
7012 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7013
7014 prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
7015 RNA_def_property_boolean_sdna(prop, nullptr, "cycl", 1);
7017 prop, "Cyclic", "Cycle the images in the movie"); /* copied from the rna_image.cc */
7018 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7019
7020 prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
7021 RNA_def_property_boolean_sdna(prop, nullptr, "flag", IMA_ANIM_ALWAYS);
7022 /* copied from the rna_image.cc */
7023 RNA_def_property_ui_text(prop, "Auto-Refresh", "Always refresh image on frame changes");
7024 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7025
7026 prop = RNA_def_property(srna, "layer", PROP_ENUM, PROP_NONE);
7027 RNA_def_property_enum_sdna(prop, nullptr, "layer");
7029 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_Node_image_layer_itemf");
7031 RNA_def_property_ui_text(prop, "Layer", "");
7032 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_image_layer_view_update");
7033
7034 prop = RNA_def_property(srna, "has_layers", PROP_BOOLEAN, PROP_NONE);
7035 RNA_def_property_boolean_funcs(prop, "rna_Node_image_has_layers_get", nullptr);
7037 RNA_def_property_ui_text(prop, "Has Layers", "True if this image has any named layer");
7038
7039 prop = RNA_def_property(srna, "view", PROP_ENUM, PROP_NONE);
7040 RNA_def_property_enum_sdna(prop, nullptr, "view");
7042 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_Node_image_view_itemf");
7044 RNA_def_property_ui_text(prop, "View", "");
7045 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_image_layer_view_update");
7046
7047 prop = RNA_def_property(srna, "has_views", PROP_BOOLEAN, PROP_NONE);
7048 RNA_def_property_boolean_funcs(prop, "rna_Node_image_has_views_get", nullptr);
7050 RNA_def_property_ui_text(prop, "Has View", "True if this image has multiple views");
7051}
7052
7053static void def_cmp_image(BlenderRNA *brna, StructRNA *srna)
7054{
7055 PropertyRNA *prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
7056 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7057 RNA_def_property_struct_type(prop, "Image");
7060 RNA_def_property_ui_text(prop, "Image", "");
7061 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Image_Node_update_id");
7063 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
7064
7065 /* NOTE: Image user properties used in the UI are redefined in def_node_image_user,
7066 * to trigger correct updates of the node editor. RNA design problem that prevents
7067 * updates from nested structs. */
7068 RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
7069 def_node_image_user(brna, srna);
7070}
7071
7072static void def_cmp_render_layers(BlenderRNA * /*brna*/, StructRNA *srna)
7073{
7074 PropertyRNA *prop;
7075
7076 prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
7077 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7078 RNA_def_property_pointer_funcs(prop, nullptr, "rna_Node_scene_set", nullptr, nullptr);
7079 RNA_def_property_struct_type(prop, "Scene");
7082 RNA_def_property_ui_text(prop, "Scene", "");
7083 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7084
7085 prop = RNA_def_property(srna, "layer", PROP_ENUM, PROP_NONE);
7086 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
7088 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_Node_view_layer_itemf");
7090 RNA_def_property_ui_text(prop, "Layer", "");
7091 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7092}
7093
7095{
7096 StructRNA *srna = RNA_def_struct(brna, "NodeCompositorFileOutputItem", nullptr);
7097 RNA_def_struct_ui_text(srna, "File Output Item", "");
7098
7099 rna_def_node_item_array_socket_item_common(srna, "FileOutputItemsAccessor", true, true);
7100
7101 PropertyRNA *prop = RNA_def_property(srna, "override_node_format", PROP_BOOLEAN, PROP_NONE);
7102 RNA_def_property_boolean_sdna(prop, nullptr, "override_node_format", 1);
7104 "Override Node Format",
7105 "Use a different format instead of the node format for this file");
7106 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
7107
7108 prop = RNA_def_property(srna, "save_as_render", PROP_BOOLEAN, PROP_NONE);
7109 RNA_def_property_boolean_sdna(prop, nullptr, "save_as_render", 1);
7111 prop, "Save as Render", "Apply render part of display transform when saving byte image");
7112 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
7113
7114 prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
7115 RNA_def_property_struct_type(prop, "ImageFormatSettings");
7116}
7117
7119{
7120 StructRNA *srna = RNA_def_struct(brna, "NodeCompositorFileOutputItems", nullptr);
7121 RNA_def_struct_sdna(srna, "bNode");
7122 RNA_def_struct_ui_text(srna, "Items", "Collection of file output items");
7123
7125 srna, "NodeCompositorFileOutputItem", "FileOutputItemsAccessor");
7127 srna, "NodeCompositorFileOutputItem", "FileOutputItemsAccessor");
7128}
7129
7131{
7132 PropertyRNA *prop;
7133
7136
7137 RNA_def_struct_sdna_from(srna, "NodeCompositorFileOutput", "storage");
7138
7139 prop = RNA_def_property(srna, "file_output_items", PROP_COLLECTION, PROP_NONE);
7140 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_count");
7141 RNA_def_property_struct_type(prop, "NodeCompositorFileOutputItem");
7142 RNA_def_property_ui_text(prop, "Items", "");
7143 RNA_def_property_srna(prop, "NodeCompositorFileOutputItems");
7144
7145 prop = RNA_def_property(srna, "active_item_index", PROP_INT, PROP_UNSIGNED);
7146 RNA_def_property_int_sdna(prop, nullptr, "active_item_index");
7147 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
7150 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
7151
7152 prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
7153 RNA_def_property_string_sdna(prop, nullptr, "directory");
7154 RNA_def_property_ui_text(prop, "Directory", "The directory where the image will be written");
7158 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7159
7160 prop = RNA_def_property(srna, "file_name", PROP_STRING, PROP_FILEPATH);
7161 RNA_def_property_string_sdna(prop, nullptr, "file_name");
7163 "File Name",
7164 "The base name of the file. Other information might be included in the "
7165 "final file name depending on the node options");
7168 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7169
7170 prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
7171 RNA_def_property_struct_type(prop, "ImageFormatSettings");
7172
7173 prop = RNA_def_property(srna, "save_as_render", PROP_BOOLEAN, PROP_NONE);
7174 RNA_def_property_boolean_sdna(prop, nullptr, "save_as_render", 1);
7177 prop, "Save as Render", "Apply render part of display transform when saving byte image");
7178 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
7179
7180 prop = RNA_def_property(srna, "use_file_extension", PROP_BOOLEAN, PROP_NONE);
7181 RNA_def_property_boolean_sdna(prop, nullptr, "use_file_extension", 1);
7184 prop,
7185 "File Extensions",
7186 "Add the file format extensions to the saved file name (eg: filename + .jpg)");
7187 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
7188}
7189
7191{
7192 PropertyRNA *prop;
7193 RNA_def_struct_sdna_from(srna, "NodeConvertColorSpace", "storage");
7194
7195 prop = RNA_def_property(srna, "from_color_space", PROP_ENUM, PROP_NONE);
7199 "rna_NodeConvertColorSpace_from_color_space_get",
7200 "rna_NodeConvertColorSpace_from_color_space_set",
7201 "rna_NodeConvertColorSpace_color_space_itemf");
7202 RNA_def_property_ui_text(prop, "From", "Color space of the input image");
7204 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7205
7206 prop = RNA_def_property(srna, "from_interop_id", PROP_ENUM, PROP_NONE);
7210 "rna_NodeConvertColorSpace_from_interop_id_get",
7211 "rna_NodeConvertColorSpace_from_interop_id_set",
7212 "rna_NodeConvertColorSpace_interop_id_itemf");
7213 RNA_def_property_ui_text(prop, "From Interop ID", "Interop ID of the input color space");
7214 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7215
7216 prop = RNA_def_property(srna, "to_color_space", PROP_ENUM, PROP_NONE);
7220 "rna_NodeConvertColorSpace_to_color_space_get",
7221 "rna_NodeConvertColorSpace_to_color_space_set",
7222 "rna_NodeConvertColorSpace_color_space_itemf");
7223 RNA_def_property_ui_text(prop, "To", "Color space of the output image");
7225 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7226
7227 prop = RNA_def_property(srna, "to_interop_id", PROP_ENUM, PROP_NONE);
7231 "rna_NodeConvertColorSpace_to_interop_id_get",
7232 "rna_NodeConvertColorSpace_to_interop_id_set",
7233 "rna_NodeConvertColorSpace_interop_id_itemf");
7234 RNA_def_property_ui_text(prop, "To Interop ID", "Interop ID of the output color space");
7235 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7236}
7237
7239{
7240 PropertyRNA *prop;
7241 RNA_def_struct_sdna_from(srna, "NodeConvertToDisplay", "storage");
7242
7243 prop = RNA_def_property(srna, "view_settings", PROP_POINTER, PROP_NONE);
7244 RNA_def_property_pointer_sdna(prop, nullptr, "view_settings");
7245 RNA_def_property_struct_type(prop, "ColorManagedViewSettings");
7246 RNA_def_property_ui_text(prop, "View Settings", "Color management view transform settings");
7247
7248 prop = RNA_def_property(srna, "display_settings", PROP_POINTER, PROP_NONE);
7249 RNA_def_property_pointer_sdna(prop, nullptr, "display_settings");
7250 RNA_def_property_struct_type(prop, "ColorManagedDisplaySettings");
7251 RNA_def_property_ui_text(prop, "Display Settings", "Color management display device settings");
7252}
7253
7254static void def_cmp_defocus(BlenderRNA * /*brna*/, StructRNA *srna)
7255{
7256 PropertyRNA *prop;
7257
7258 static const EnumPropertyItem bokeh_items[] = {
7259 {8, "OCTAGON", 0, "Octagonal", "8 sides"},
7260 {7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
7261 {6, "HEXAGON", 0, "Hexagonal", "6 sides"},
7262 {5, "PENTAGON", 0, "Pentagonal", "5 sides"},
7263 {4, "SQUARE", 0, "Square", "4 sides"},
7264 {3, "TRIANGLE", 0, "Triangular", "3 sides"},
7265 {0, "CIRCLE", 0, "Circular", ""},
7266 {0, nullptr, 0, nullptr, nullptr},
7267 };
7268
7269 prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
7270 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7271 RNA_def_property_pointer_funcs(prop, nullptr, "rna_Node_scene_set", nullptr, nullptr);
7272 RNA_def_property_struct_type(prop, "Scene");
7276 prop, "Scene", "Scene from which to select the active camera (render scene if undefined)");
7277 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7278
7279 RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
7280
7281 prop = RNA_def_property(srna, "bokeh", PROP_ENUM, PROP_NONE);
7282 RNA_def_property_enum_sdna(prop, nullptr, "bktype");
7283 RNA_def_property_enum_items(prop, bokeh_items);
7284 RNA_def_property_ui_text(prop, "Bokeh Type", "");
7285 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7286
7287 prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
7288 RNA_def_property_float_sdna(prop, nullptr, "rotation");
7289 RNA_def_property_range(prop, 0.0f, DEG2RADF(90.0f));
7290 RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset");
7291 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7292
7293 prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
7294 RNA_def_property_float_sdna(prop, nullptr, "fstop");
7295 RNA_def_property_range(prop, 0.0f, 128.0f);
7296 RNA_def_property_float_default(prop, 128.0f);
7298 prop,
7299 "F-Stop",
7300 "Amount of focal blur, 128 (infinity) is perfect focus, half the value doubles "
7301 "the blur radius");
7302 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7303
7304 prop = RNA_def_property(srna, "blur_max", PROP_FLOAT, PROP_PIXEL);
7305 RNA_def_property_float_sdna(prop, nullptr, "maxblur");
7306 RNA_def_property_range(prop, 0.0f, 10000.0f);
7307 RNA_def_property_float_default(prop, 16.0f);
7308 RNA_def_property_ui_text(prop, "Max Blur", "Blur limit, maximum CoC radius");
7309 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7310
7311 prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
7312 RNA_def_property_boolean_negative_sdna(prop, nullptr, "no_zbuf", 1);
7314 "Use Z-Buffer",
7315 "Disable when using an image as input instead of actual z-buffer "
7316 "(auto enabled if node not image based, eg. time node)");
7317 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7318
7319 prop = RNA_def_property(srna, "z_scale", PROP_FLOAT, PROP_NONE);
7320 RNA_def_property_float_sdna(prop, nullptr, "scale");
7321 RNA_def_property_range(prop, 0.0f, 1000.0f);
7324 prop,
7325 "Z-Scale",
7326 "Scale the Z input when not using a z-buffer, controls maximum blur designated "
7327 "by the color white or input value 1");
7328 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7329}
7330
7331static void def_cmp_colorbalance(BlenderRNA * /*brna*/, StructRNA *srna)
7332{
7333 PropertyRNA *prop;
7334
7335 prop = RNA_def_property(srna, "input_whitepoint", PROP_FLOAT, PROP_COLOR);
7336 RNA_def_property_array(prop, 3);
7338 "rna_NodeColorBalance_input_whitepoint_get",
7339 "rna_NodeColorBalance_input_whitepoint_set",
7340 nullptr);
7342 "Input White Point",
7343 "The color which gets mapped to white "
7344 "(automatically converted to/from temperature and tint)");
7345 RNA_def_property_update(prop, NC_WINDOW, "rna_Node_update");
7346
7347 prop = RNA_def_property(srna, "output_whitepoint", PROP_FLOAT, PROP_COLOR);
7348 RNA_def_property_array(prop, 3);
7350 "rna_NodeColorBalance_output_whitepoint_get",
7351 "rna_NodeColorBalance_output_whitepoint_set",
7352 nullptr);
7354 "Output White Point",
7355 "The color which gets white gets mapped to "
7356 "(automatically converted to/from temperature and tint)");
7357 RNA_def_property_update(prop, NC_WINDOW, "rna_Node_update");
7358}
7359
7360static void def_cmp_huecorrect(BlenderRNA * /*brna*/, StructRNA *srna)
7361{
7362 PropertyRNA *prop;
7363
7364 prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
7365 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
7366 RNA_def_property_struct_type(prop, "CurveMapping");
7367 RNA_def_property_ui_text(prop, "Mapping", "");
7368 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7369}
7370
7371static void def_cmp_combsep_color(BlenderRNA * /*brna*/, StructRNA *srna)
7372{
7373 static const EnumPropertyItem mode_items[] = {
7375 "RGB",
7376 ICON_NONE,
7377 "RGB",
7378 "Use RGB (Red, Green, Blue) color processing"},
7380 "HSV",
7381 ICON_NONE,
7382 "HSV",
7383 "Use HSV (Hue, Saturation, Value) color processing"},
7385 "HSL",
7386 ICON_NONE,
7387 "HSL",
7388 "Use HSL (Hue, Saturation, Lightness) color processing"},
7390 "YCC",
7391 ICON_NONE,
7392 "YCbCr",
7393 "Use YCbCr (Y - luma, Cb - blue-difference chroma, Cr - red-difference chroma) color "
7394 "processing"},
7396 "YUV",
7397 ICON_NONE,
7398 "YUV",
7399 "Use YUV (Y - luma, U V - chroma) color processing"},
7400 {0, nullptr, 0, nullptr, nullptr},
7401 };
7402
7403 PropertyRNA *prop;
7404
7405 RNA_def_struct_sdna_from(srna, "NodeCMPCombSepColor", "storage");
7406
7407 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
7408 RNA_def_property_enum_items(prop, mode_items);
7409 RNA_def_property_ui_text(prop, "Mode", "Mode of color processing");
7410 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7411
7412 prop = RNA_def_property(srna, "ycc_mode", PROP_ENUM, PROP_NONE);
7414 RNA_def_property_enum_default(prop, 1); /* ITU BT.709 */
7415 RNA_def_property_ui_text(prop, "Color Space", "Color space used for YCbCrA processing");
7416 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7417}
7418
7419static void def_cmp_movieclip(BlenderRNA * /*brna*/, StructRNA *srna)
7420{
7421 PropertyRNA *prop;
7422
7423 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7424 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7425 RNA_def_property_struct_type(prop, "MovieClip");
7428 RNA_def_property_ui_text(prop, "Movie Clip", "");
7429 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7430
7431 RNA_def_struct_sdna_from(srna, "MovieClipUser", "storage");
7432}
7433
7434static void def_cmp_stabilize2d(BlenderRNA * /*brna*/, StructRNA *srna)
7435{
7436 PropertyRNA *prop;
7437
7438 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7439 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7440 RNA_def_property_struct_type(prop, "MovieClip");
7443 RNA_def_property_ui_text(prop, "Movie Clip", "");
7444 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7445}
7446
7447static void def_cmp_moviedistortion(BlenderRNA * /*brna*/, StructRNA *srna)
7448{
7449 PropertyRNA *prop;
7450
7451 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7452 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7453 RNA_def_property_struct_type(prop, "MovieClip");
7456 RNA_def_property_ui_text(prop, "Movie Clip", "");
7457 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7458}
7459
7460static void def_cmp_mask(BlenderRNA * /*brna*/, StructRNA *srna)
7461{
7462 PropertyRNA *prop;
7463
7464 prop = RNA_def_property(srna, "mask", PROP_POINTER, PROP_NONE);
7465 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7466 RNA_def_property_struct_type(prop, "Mask");
7469 RNA_def_property_ui_text(prop, "Mask", "");
7470 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7471}
7472
7473static void def_cmp_viewer(BlenderRNA * /*brna*/, StructRNA *srna)
7474{
7475 PropertyRNA *prop = RNA_def_property(srna, "ui_shortcut", PROP_INT, PROP_NONE);
7476 RNA_def_property_int_sdna(prop, nullptr, "custom1");
7477 RNA_def_property_int_funcs(prop, nullptr, "rna_Node_Viewer_shortcut_node_set", nullptr);
7481 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
7482}
7483
7484static void def_cmp_keyingscreen(BlenderRNA * /*brna*/, StructRNA *srna)
7485{
7486 PropertyRNA *prop;
7487
7488 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7489 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7490 RNA_def_property_struct_type(prop, "MovieClip");
7493 RNA_def_property_ui_text(prop, "Movie Clip", "");
7494 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7495
7496 RNA_def_struct_sdna_from(srna, "NodeKeyingScreenData", "storage");
7497
7498 prop = RNA_def_property(srna, "tracking_object", PROP_STRING, PROP_NONE);
7499 RNA_def_property_string_sdna(prop, nullptr, "tracking_object");
7500 RNA_def_property_ui_text(prop, "Tracking Object", "");
7501 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7502}
7503
7504static void def_cmp_trackpos(BlenderRNA * /*brna*/, StructRNA *srna)
7505{
7506 PropertyRNA *prop;
7507
7508 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7509 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7510 RNA_def_property_struct_type(prop, "MovieClip");
7513 RNA_def_property_ui_text(prop, "Movie Clip", "");
7514 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7515
7516 RNA_def_struct_sdna_from(srna, "NodeTrackPosData", "storage");
7517
7518 prop = RNA_def_property(srna, "tracking_object", PROP_STRING, PROP_NONE);
7519 RNA_def_property_string_sdna(prop, nullptr, "tracking_object");
7520 RNA_def_property_ui_text(prop, "Tracking Object", "");
7521 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7522
7523 prop = RNA_def_property(srna, "track_name", PROP_STRING, PROP_NONE);
7524 RNA_def_property_string_sdna(prop, nullptr, "track_name");
7525 RNA_def_property_ui_text(prop, "Track", "");
7527 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7528}
7529
7530static void def_cmp_planetrackdeform(BlenderRNA * /*brna*/, StructRNA *srna)
7531{
7532 PropertyRNA *prop;
7533
7534 prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
7535 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7536 RNA_def_property_struct_type(prop, "MovieClip");
7539 RNA_def_property_ui_text(prop, "Movie Clip", "");
7540 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7541
7542 RNA_def_struct_sdna_from(srna, "NodePlaneTrackDeformData", "storage");
7543
7544 prop = RNA_def_property(srna, "tracking_object", PROP_STRING, PROP_NONE);
7545 RNA_def_property_string_sdna(prop, nullptr, "tracking_object");
7546 RNA_def_property_ui_text(prop, "Tracking Object", "");
7547 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7548
7549 prop = RNA_def_property(srna, "plane_track_name", PROP_STRING, PROP_NONE);
7550 RNA_def_property_string_sdna(prop, nullptr, "plane_track_name");
7551 RNA_def_property_ui_text(prop, "Plane Track", "");
7552 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7553}
7554
7556{
7557 StructRNA *srna;
7558 PropertyRNA *prop;
7559
7560 srna = RNA_def_struct(brna, "CryptomatteEntry", nullptr);
7561 RNA_def_struct_sdna(srna, "CryptomatteEntry");
7562
7563 prop = RNA_def_property(srna, "encoded_hash", PROP_FLOAT, PROP_NONE);
7565 RNA_def_property_float_sdna(prop, nullptr, "encoded_hash");
7566
7567 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
7569 RNA_def_property_ui_text(prop, "Name", "");
7570 RNA_def_struct_name_property(srna, prop);
7571}
7572
7574{
7575 PropertyRNA *prop;
7576
7577 prop = RNA_def_property(srna, "matte_id", PROP_STRING, PROP_NONE);
7579 "rna_NodeCryptomatte_matte_get",
7580 "rna_NodeCryptomatte_matte_length",
7581 "rna_NodeCryptomatte_matte_set");
7583 prop, "Matte Objects", "List of object and material crypto IDs to include in matte");
7584 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7585
7586 prop = RNA_def_property(srna, "add", PROP_FLOAT, PROP_COLOR);
7587 RNA_def_property_float_sdna(prop, nullptr, "runtime.add");
7590 prop, "Add", "Add object or material to matte, by picking a color from the Pick output");
7592 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeCryptomatte_update_add");
7593
7594 prop = RNA_def_property(srna, "remove", PROP_FLOAT, PROP_COLOR);
7595 RNA_def_property_float_sdna(prop, nullptr, "runtime.remove");
7598 prop,
7599 "Remove",
7600 "Remove object or material from matte, by picking a color from the Pick output");
7602 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeCryptomatte_update_remove");
7603}
7604
7606{
7607 RNA_def_struct_sdna_from(srna, "NodeCryptomatte", "storage");
7608 def_cmp_cryptomatte_common(brna, srna);
7609}
7610
7612{
7613 PropertyRNA *prop;
7614
7615 static const EnumPropertyItem cryptomatte_source_items[] = {
7617 "RENDER",
7618 0,
7619 "Render",
7620 "Use Cryptomatte passes from a render"},
7622 "IMAGE",
7623 0,
7624 "Image",
7625 "Use Cryptomatte passes from an image"},
7626 {0, nullptr, 0, nullptr, nullptr}};
7627
7628 prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
7629 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
7630 RNA_def_property_enum_items(prop, cryptomatte_source_items);
7631 RNA_def_property_enum_funcs(prop, nullptr, "rna_NodeCryptomatte_source_set", nullptr);
7632 RNA_def_property_ui_text(prop, "Source", "Where the Cryptomatte passes are loaded from");
7633 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7634
7635 prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
7637 prop, "rna_NodeCryptomatte_scene_get", "rna_NodeCryptomatte_scene_set", nullptr, nullptr);
7638 RNA_def_property_struct_type(prop, "Scene");
7641 RNA_def_property_ui_text(prop, "Scene", "");
7642 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7643
7644 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
7646 "rna_NodeCryptomatte_image_get",
7647 "rna_NodeCryptomatte_image_set",
7648 nullptr,
7649 "rna_NodeCryptomatte_image_poll");
7650 RNA_def_property_struct_type(prop, "Image");
7653 RNA_def_property_ui_text(prop, "Image", "");
7654 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
7655
7656 RNA_def_struct_sdna_from(srna, "NodeCryptomatte", "storage");
7657 def_cmp_cryptomatte_common(brna, srna);
7658
7659 prop = RNA_def_property(srna, "layer_name", PROP_ENUM, PROP_NONE);
7662 "rna_NodeCryptomatte_layer_name_get",
7663 "rna_NodeCryptomatte_layer_name_set",
7664 "rna_NodeCryptomatte_layer_name_itemf");
7665 RNA_def_property_ui_text(prop, "Cryptomatte Layer", "What Cryptomatte layer is used");
7666 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7667
7668 prop = RNA_def_property(srna, "entries", PROP_COLLECTION, PROP_NONE);
7669 RNA_def_property_collection_sdna(prop, nullptr, "entries", nullptr);
7670 RNA_def_property_struct_type(prop, "CryptomatteEntry");
7671 RNA_def_property_ui_text(prop, "Mattes", "");
7673
7674 /* Included here instead of defining image_user as a property of the node,
7675 * see def_cmp_image for details.
7676 * As mentioned in DNA_node_types.h, iuser is the first member of the Cryptomatte
7677 * storage type, so we can cast node->storage to ImageUser.
7678 * That is required since we can't define the properties from storage->iuser directly... */
7679 RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
7680 def_node_image_user(brna, srna);
7681}
7682
7683/* -- Texture Nodes --------------------------------------------------------- */
7684
7685static void def_tex_output(BlenderRNA * /*brna*/, StructRNA *srna)
7686{
7687 PropertyRNA *prop;
7688
7689 RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage");
7690
7691 prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_NONE);
7692 RNA_def_property_string_sdna(prop, nullptr, "name");
7693 RNA_def_property_ui_text(prop, "Output Name", "");
7694 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7695}
7696
7697static void def_tex_image(BlenderRNA * /*brna*/, StructRNA *srna)
7698{
7699 PropertyRNA *prop;
7700
7701 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
7702 RNA_def_property_pointer_sdna(prop, nullptr, "id");
7703 RNA_def_property_struct_type(prop, "Image");
7706 RNA_def_property_ui_text(prop, "Image", "");
7707 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7709 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
7710
7711 prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
7712 RNA_def_property_pointer_sdna(prop, nullptr, "storage");
7713 RNA_def_property_struct_type(prop, "ImageUser");
7715 prop, "Image User", "Parameters defining the image duration, offset and related settings");
7716 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7717}
7718
7719static void def_tex_bricks(BlenderRNA * /*brna*/, StructRNA *srna)
7720{
7721 PropertyRNA *prop;
7722
7723 prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
7724 RNA_def_property_float_sdna(prop, nullptr, "custom3");
7725 RNA_def_property_range(prop, 0.0f, 1.0f);
7728 prop, "Offset Amount", "Determines the brick offset of the various rows");
7729 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7730
7731 prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
7732 RNA_def_property_int_sdna(prop, nullptr, "custom1");
7733 RNA_def_property_range(prop, 2, 99);
7734 RNA_def_property_ui_text(prop, "Offset Frequency", "Offset every N rows");
7735 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7736
7737 prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
7738 RNA_def_property_float_sdna(prop, nullptr, "custom4");
7739 RNA_def_property_range(prop, 0.0f, 99.0f);
7742 prop,
7743 "Squash Amount",
7744 "Factor to adjust the brick's width for particular rows determined by the Offset Frequency");
7745
7746 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7747
7748 prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
7749 RNA_def_property_int_sdna(prop, nullptr, "custom2");
7750 RNA_def_property_range(prop, 2, 99);
7751 RNA_def_property_ui_text(prop, "Squash Frequency", "Squash every N rows");
7752 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
7753}
7754
7755/* -- Geometry Nodes --------------------------------------------------------- */
7756
7757static void def_geo_curve_sample(BlenderRNA * /*brna*/, StructRNA *srna)
7758{
7759 static EnumPropertyItem mode_items[] = {
7761 "FACTOR",
7762 0,
7763 "Factor",
7764 "Find sample positions on the curve using a factor of its total length"},
7766 "LENGTH",
7767 0,
7768 "Length",
7769 "Find sample positions on the curve using a distance from its beginning"},
7770 {0, nullptr, 0, nullptr, nullptr},
7771 };
7772
7773 RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSample", "storage");
7774
7775 PropertyRNA *prop;
7776 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
7777 RNA_def_property_enum_items(prop, mode_items);
7778 RNA_def_property_ui_text(prop, "Mode", "Method for sampling input");
7780 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7781
7782 prop = RNA_def_property(srna, "use_all_curves", PROP_BOOLEAN, PROP_NONE);
7784 "All Curves",
7785 "Sample lengths based on the total length of all curves, rather than "
7786 "using a length inside each selected curve");
7788 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7789
7790 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
7793 prop, nullptr, nullptr, "rna_GeometryNodeAttributeType_type_with_socket_itemf");
7795 RNA_def_property_ui_text(prop, "Data Type", "");
7797 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7798}
7799
7800static void def_fn_random_value(BlenderRNA * /*brna*/, StructRNA *srna)
7801{
7802 PropertyRNA *prop;
7803
7804 RNA_def_struct_sdna_from(srna, "NodeRandomValue", "storage");
7805
7806 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
7807 RNA_def_property_enum_sdna(prop, nullptr, "data_type");
7809 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_FunctionNodeRandomValue_type_itemf");
7811 RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute");
7812 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7813}
7814
7816{
7817 PropertyRNA *prop;
7818
7819 static const EnumPropertyItem rna_node_geometry_distribute_points_on_faces_mode_items[] = {
7821 "RANDOM",
7822 0,
7823 "Random",
7824 "Distribute points randomly on the surface"},
7826 "POISSON",
7827 0,
7828 "Poisson Disk",
7829 "Distribute the points randomly on the surface while taking a minimum distance between "
7830 "points into account"},
7831 {0, nullptr, 0, nullptr, nullptr},
7832 };
7833
7834 prop = RNA_def_property(srna, "distribute_method", PROP_ENUM, PROP_NONE);
7835 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
7836 RNA_def_property_enum_items(prop, rna_node_geometry_distribute_points_on_faces_mode_items);
7838 RNA_def_property_ui_text(prop, "Distribution Method", "Method to use for scattering points");
7840 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7841
7842 prop = RNA_def_property(srna, "use_legacy_normal", PROP_BOOLEAN, PROP_NONE);
7843 RNA_def_property_boolean_sdna(prop, nullptr, "custom2", 1);
7845 "Legacy Normal",
7846 "Output the normal and rotation values that have been output "
7847 "before the node started taking smooth normals into account");
7849 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7850}
7851
7853{
7854 PropertyRNA *prop;
7855
7856 RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSetHandles", "storage");
7857
7858 prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
7859 RNA_def_property_enum_sdna(prop, nullptr, "handle_type");
7860 RNA_def_property_ui_text(prop, "Handle Type", "");
7864 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7865
7866 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
7871 RNA_def_property_ui_text(prop, "Mode", "Whether to update left and right handles");
7872 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
7873}
7874
7875static void def_common_zone_input(BlenderRNA * /*brna*/, StructRNA *srna)
7876{
7877 PropertyRNA *prop;
7878 FunctionRNA *func;
7879 PropertyRNA *parm;
7880
7881 prop = RNA_def_property(srna, "paired_output", PROP_POINTER, PROP_NONE);
7882 RNA_def_property_struct_type(prop, "Node");
7884 RNA_def_property_pointer_funcs(prop, "rna_Node_paired_output_get", nullptr, nullptr, nullptr);
7886 prop, "Paired Output", "Zone output node that this input node is paired with");
7887
7888 func = RNA_def_function(srna, "pair_with_output", "rna_Node_pair_with_output");
7889 RNA_def_function_ui_description(func, "Pair a zone input node with an output node.");
7891 parm = RNA_def_pointer(
7892 func, "output_node", "NodeInternal", "Output Node", "Zone output node to pair with");
7894 /* return value */
7895 parm = RNA_def_boolean(
7896 func, "result", false, "Result", "True if pairing the node was successful");
7897 RNA_def_function_return(func, parm);
7898}
7899
7901{
7902 RNA_def_struct_sdna_from(srna, "NodeGeometrySimulationInput", "storage");
7903
7904 def_common_zone_input(brna, srna);
7905}
7906
7908{
7909 RNA_def_struct_sdna_from(srna, "NodeGeometryRepeatInput", "storage");
7910
7911 def_common_zone_input(brna, srna);
7912}
7913
7915{
7916 RNA_def_struct_sdna_from(srna, "NodeGeometryForeachGeometryElementInput", "storage");
7917
7918 def_common_zone_input(brna, srna);
7919}
7920
7921static void def_closure_input(BlenderRNA *brna, StructRNA *srna)
7922{
7923 RNA_def_struct_sdna_from(srna, "NodeClosureInput", "storage");
7924
7925 def_common_zone_input(brna, srna);
7926}
7927
7929{
7930 PropertyRNA *prop;
7931
7932 StructRNA *srna = RNA_def_struct(brna, "SimulationStateItem", nullptr);
7933 RNA_def_struct_ui_text(srna, "Simulation Item", "");
7934 RNA_def_struct_sdna(srna, "NodeSimulationItem");
7935
7936 rna_def_node_item_array_socket_item_common(srna, "SimulationItemsAccessor", true);
7937
7938 prop = RNA_def_property(srna, "attribute_domain", PROP_ENUM, PROP_NONE);
7941 prop, nullptr, nullptr, "rna_GeometryNodeAttributeDomain_attribute_domain_itemf");
7943 prop,
7944 "Attribute Domain",
7945 "Domain where the field is captured if it is not already an attribute-field");
7948 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<SimulationItemsAccessor>");
7949}
7950
7952{
7953 StructRNA *srna;
7954
7955 srna = RNA_def_struct(brna, "NodeGeometrySimulationOutputItems", nullptr);
7956 RNA_def_struct_sdna(srna, "bNode");
7957 RNA_def_struct_ui_text(srna, "Items", "Collection of simulation items");
7958
7960 srna, "SimulationStateItem", "SimulationItemsAccessor");
7961 rna_def_node_item_array_common_functions(srna, "SimulationStateItem", "SimulationItemsAccessor");
7962}
7963
7965{
7966 PropertyRNA *prop;
7967
7970
7971 RNA_def_struct_sdna_from(srna, "NodeGeometrySimulationOutput", "storage");
7972
7973 prop = RNA_def_property(srna, "state_items", PROP_COLLECTION, PROP_NONE);
7974 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
7975 RNA_def_property_struct_type(prop, "SimulationStateItem");
7976 RNA_def_property_ui_text(prop, "Items", "");
7977 RNA_def_property_srna(prop, "NodeGeometrySimulationOutputItems");
7978
7979 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
7980 RNA_def_property_int_sdna(prop, nullptr, "active_index");
7981 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
7984 RNA_def_property_update(prop, NC_NODE, nullptr);
7985
7986 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
7987 RNA_def_property_struct_type(prop, "SimulationStateItem");
7989 "rna_Node_ItemArray_active_get<SimulationItemsAccessor>",
7990 "rna_Node_ItemArray_active_set<SimulationItemsAccessor>",
7991 nullptr,
7992 nullptr);
7994 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
7995 RNA_def_property_update(prop, NC_NODE, nullptr);
7996}
7997
7998static void def_geo_merge_layers(BlenderRNA * /*brna*/, StructRNA *srna)
7999{
8000 PropertyRNA *prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
8002 RNA_def_property_ui_text(prop, "Mode", "Determines how to choose which layers are merged");
8004 prop, "rna_MergeLayers_mode_get", "rna_MergeLayers_mode_set", nullptr);
8005 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
8006 RNA_def_property_deprecated(prop, "Replaced by '.inputs[\"Mode\"]'.", 503, 600);
8007}
8008
8010{
8011 PropertyRNA *prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
8013 RNA_def_property_ui_text(prop, "Mode", "Set the color and opacity for strokes or fills");
8015 prop, "rna_SetGreasePencilColor_mode_get", "rna_SetGreasePencilColor_mode_set", nullptr);
8016 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
8017 RNA_def_property_deprecated(prop, "Replaced by '.inputs[\"Mode\"]'.", 503, 600);
8018}
8019
8021{
8022 PropertyRNA *prop = RNA_def_property(srna, "depth_order", PROP_ENUM, PROP_NONE);
8024 RNA_def_property_ui_text(prop, "Depth Order", "");
8026 "rna_SetGreasePencilDepth_depth_order_get",
8027 "rna_SetGreasePencilDepth_depth_order_set",
8028 nullptr);
8029 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
8030 RNA_def_property_deprecated(prop, "Replaced by '.inputs[\"Depth Order\"]'.", 503, 600);
8031}
8032
8034{
8035 StructRNA *srna = RNA_def_struct(brna, "RepeatItem", nullptr);
8036 RNA_def_struct_ui_text(srna, "Repeat Item", "");
8037 RNA_def_struct_sdna(srna, "NodeRepeatItem");
8038
8039 rna_def_node_item_array_socket_item_common(srna, "RepeatItemsAccessor", true);
8040}
8041
8043{
8044 StructRNA *srna;
8045
8046 srna = RNA_def_struct(brna, "NodeGeometryRepeatOutputItems", nullptr);
8047 RNA_def_struct_sdna(srna, "bNode");
8048 RNA_def_struct_ui_text(srna, "Items", "Collection of repeat items");
8049
8050 rna_def_node_item_array_new_with_socket_and_name(srna, "RepeatItem", "RepeatItemsAccessor");
8051 rna_def_node_item_array_common_functions(srna, "RepeatItem", "RepeatItemsAccessor");
8052}
8053
8055{
8056 PropertyRNA *prop;
8057
8060
8061 RNA_def_struct_sdna_from(srna, "NodeGeometryRepeatOutput", "storage");
8062
8063 prop = RNA_def_property(srna, "repeat_items", PROP_COLLECTION, PROP_NONE);
8064 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8065 RNA_def_property_struct_type(prop, "RepeatItem");
8066 RNA_def_property_ui_text(prop, "Items", "");
8067 RNA_def_property_srna(prop, "NodeGeometryRepeatOutputItems");
8068
8069 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8070 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8071 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8074 RNA_def_property_update(prop, NC_NODE, nullptr);
8075
8076 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
8077 RNA_def_property_struct_type(prop, "RepeatItem");
8079 "rna_Node_ItemArray_active_get<RepeatItemsAccessor>",
8080 "rna_Node_ItemArray_active_set<RepeatItemsAccessor>",
8081 nullptr,
8082 nullptr);
8084 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8085 RNA_def_property_update(prop, NC_NODE, nullptr);
8086
8087 prop = RNA_def_property(srna, "inspection_index", PROP_INT, PROP_NONE);
8088 RNA_def_property_ui_range(prop, 0, INT32_MAX, 1, -1);
8090 "Inspection Index",
8091 "Iteration index that is used by inspection features like the viewer "
8092 "node or socket inspection");
8093 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8094}
8095
8097{
8098 PropertyRNA *prop;
8099
8100 StructRNA *srna = RNA_def_struct(brna, "NodeGeometryViewerItem", nullptr);
8101 RNA_def_struct_ui_text(srna, "Viewer Item", "");
8102 RNA_def_struct_sdna(srna, "NodeGeometryViewerItem");
8103
8104 rna_def_node_item_array_socket_item_common(srna, "GeoViewerItemsAccessor", true);
8105
8106 prop = RNA_def_property(srna, "auto_remove", PROP_BOOLEAN, PROP_NONE);
8111 prop, "Auto Remove", "Remove the item automatically when it is unlinked");
8113 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<GeoViewerItemsAccessor>");
8114}
8115
8117{
8118 StructRNA *srna = RNA_def_struct(brna, "NodeGeometryViewerItems", nullptr);
8119 RNA_def_struct_sdna(srna, "bNode");
8120 RNA_def_struct_ui_text(srna, "Items", "Collection of viewer items");
8121
8123 srna, "NodeGeometryViewerItem", "GeoViewerItemsAccessor");
8125 srna, "NodeGeometryViewerItem", "GeoViewerItemsAccessor");
8126}
8127
8128static void rna_def_geo_viewer(BlenderRNA *brna, StructRNA *srna)
8129{
8130 PropertyRNA *prop;
8131
8134
8135 prop = RNA_def_property(srna, "ui_shortcut", PROP_INT, PROP_NONE);
8136 RNA_def_property_int_sdna(prop, nullptr, "custom1");
8137 RNA_def_property_int_funcs(prop, nullptr, "rna_Node_Viewer_shortcut_node_set", nullptr);
8141 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
8142
8143 RNA_def_struct_sdna_from(srna, "NodeGeometryViewer", "storage");
8144
8145 prop = RNA_def_property(srna, "viewer_items", PROP_COLLECTION, PROP_NONE);
8146 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8147 RNA_def_property_struct_type(prop, "NodeGeometryViewerItem");
8148 RNA_def_property_ui_text(prop, "Viewer Items", "");
8149 RNA_def_property_srna(prop, "NodeGeometryViewerItems");
8150
8151 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8152 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8153 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8156 RNA_def_property_update(prop, NC_NODE, nullptr);
8157
8158 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
8159 RNA_def_property_struct_type(prop, "NodeGeometryViewerItem");
8160 RNA_def_property_ui_text(prop, "Active Item", "");
8163 "rna_Node_ItemArray_active_get<GeoViewerItemsAccessor>",
8164 "rna_Node_ItemArray_active_set<GeoViewerItemsAccessor>",
8165 nullptr,
8166 nullptr);
8167
8168 prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE);
8172 RNA_def_property_ui_text(prop, "Domain", "Domain to evaluate fields on");
8173 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
8174}
8175
8177{
8178 StructRNA *srna = RNA_def_struct(brna, "ForeachGeometryElementInputItem", nullptr);
8179 RNA_def_struct_ui_text(srna, "For Each Geometry Element Item", "");
8180 RNA_def_struct_sdna(srna, "NodeForeachGeometryElementInputItem");
8181
8183 srna, "ForeachGeometryElementInputItemsAccessor", true);
8184}
8185
8187{
8188 StructRNA *srna;
8189
8190 srna = RNA_def_struct(brna, "NodeGeometryForeachGeometryElementInputItems", nullptr);
8191 RNA_def_struct_sdna(srna, "bNode");
8192 RNA_def_struct_ui_text(srna, "Input Items", "Collection of input items");
8193
8195 srna, "ForeachGeometryElementInputItem", "ForeachGeometryElementInputItemsAccessor");
8197 srna, "ForeachGeometryElementInputItem", "ForeachGeometryElementInputItemsAccessor");
8198}
8199
8201{
8202 StructRNA *srna;
8203
8204 srna = RNA_def_struct(brna, "ForeachGeometryElementMainItem", nullptr);
8205 RNA_def_struct_ui_text(srna, "For Each Geometry Element Item", "");
8206 RNA_def_struct_sdna(srna, "NodeForeachGeometryElementMainItem");
8207
8209 srna, "ForeachGeometryElementMainItemsAccessor", true);
8210}
8211
8213{
8214 StructRNA *srna;
8215
8216 srna = RNA_def_struct(brna, "NodeGeometryForeachGeometryElementMainItems", nullptr);
8217 RNA_def_struct_sdna(srna, "bNode");
8218 RNA_def_struct_ui_text(srna, "Main Items", "Collection of main items");
8219
8221 srna, "ForeachGeometryElementMainItem", "ForeachGeometryElementMainItemsAccessor");
8223 srna, "ForeachGeometryElementMainItem", "ForeachGeometryElementMainItemsAccessor");
8224}
8225
8227{
8228 StructRNA *srna;
8229 PropertyRNA *prop;
8230
8231 srna = RNA_def_struct(brna, "ForeachGeometryElementGenerationItem", nullptr);
8232 RNA_def_struct_ui_text(srna, "For Each Geometry Element Item", "");
8233 RNA_def_struct_sdna(srna, "NodeForeachGeometryElementGenerationItem");
8234
8236 srna, "ForeachGeometryElementGenerationItemsAccessor", true);
8237
8238 prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE);
8239 RNA_def_property_ui_text(prop, "Domain", "Domain that the field is evaluated on");
8242 prop,
8244 "rna_Node_ItemArray_item_update<ForeachGeometryElementGenerationItemsAccessor>");
8245}
8246
8248{
8249 StructRNA *srna;
8250
8251 srna = RNA_def_struct(brna, "NodeGeometryForeachGeometryElementGenerationItems", nullptr);
8252 RNA_def_struct_sdna(srna, "bNode");
8253 RNA_def_struct_ui_text(srna, "Generation Items", "Collection of generation items");
8254
8256 srna,
8257 "ForeachGeometryElementGenerationItem",
8258 "ForeachGeometryElementGenerationItemsAccessor");
8260 "ForeachGeometryElementGenerationItem",
8261 "ForeachGeometryElementGenerationItemsAccessor");
8262}
8263
8265{
8266 PropertyRNA *prop;
8267
8270
8273
8276
8277 RNA_def_struct_sdna_from(srna, "NodeGeometryForeachGeometryElementOutput", "storage");
8278
8279 prop = RNA_def_property(srna, "input_items", PROP_COLLECTION, PROP_NONE);
8280 RNA_def_property_collection_sdna(prop, nullptr, "input_items.items", "input_items.items_num");
8281 RNA_def_property_struct_type(prop, "ForeachGeometryElementInputItem");
8282 RNA_def_property_srna(prop, "NodeGeometryForeachGeometryElementInputItems");
8283
8284 prop = RNA_def_property(srna, "main_items", PROP_COLLECTION, PROP_NONE);
8285 RNA_def_property_collection_sdna(prop, nullptr, "main_items.items", "main_items.items_num");
8286 RNA_def_property_struct_type(prop, "ForeachGeometryElementMainItem");
8287 RNA_def_property_srna(prop, "NodeGeometryForeachGeometryElementMainItems");
8288
8289 prop = RNA_def_property(srna, "generation_items", PROP_COLLECTION, PROP_NONE);
8291 prop, nullptr, "generation_items.items", "generation_items.items_num");
8292 RNA_def_property_struct_type(prop, "ForeachGeometryElementGenerationItem");
8293 RNA_def_property_srna(prop, "NodeGeometryForeachGeometryElementGenerationItems");
8294
8295 prop = RNA_def_property(srna, "active_input_index", PROP_INT, PROP_UNSIGNED);
8296 RNA_def_property_int_sdna(prop, nullptr, "input_items.active_index");
8297 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8300 RNA_def_property_update(prop, NC_NODE, nullptr);
8301
8302 prop = RNA_def_property(srna, "active_generation_index", PROP_INT, PROP_UNSIGNED);
8303 RNA_def_property_int_sdna(prop, nullptr, "generation_items.active_index");
8304 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8307 RNA_def_property_update(prop, NC_NODE, nullptr);
8308
8309 prop = RNA_def_property(srna, "active_main_index", PROP_INT, PROP_UNSIGNED);
8310 RNA_def_property_int_sdna(prop, nullptr, "main_items.active_index");
8311 RNA_def_property_ui_text(prop, "Active Main Item Index", "Index of the active item");
8314 RNA_def_property_update(prop, NC_NODE, nullptr);
8315
8316 prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE);
8317 RNA_def_property_ui_text(prop, "Domain", "Geometry domain that is iterated over");
8319 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
8320
8321 prop = RNA_def_property(srna, "inspection_index", PROP_INT, PROP_NONE);
8322 RNA_def_property_ui_range(prop, 0, INT32_MAX, 1, -1);
8324 "Inspection Index",
8325 "Iteration index that is used by inspection features like the viewer "
8326 "node or socket inspection");
8327 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8328}
8329
8331{
8332 StructRNA *srna;
8333 PropertyRNA *prop;
8334
8335 srna = RNA_def_struct(brna, "NodeClosureInputItem", nullptr);
8336 RNA_def_struct_ui_text(srna, "Closure Input Item", "");
8337 RNA_def_struct_sdna(srna, "NodeClosureInputItem");
8338
8339 rna_def_node_item_array_socket_item_common(srna, "ClosureInputItemsAccessor", true);
8340
8341 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8344 prop,
8345 nullptr,
8346 nullptr,
8347 "rna_Node_ItemArray_structure_type_itemf<ClosureInputItemsAccessor>");
8349 prop,
8350 "Structure Type",
8351 "What kind of higher order types are expected to flow through this socket");
8353 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<ClosureInputItemsAccessor>");
8354}
8355
8357{
8358 StructRNA *srna = RNA_def_struct(brna, "NodeClosureInputItems", nullptr);
8359 RNA_def_struct_ui_text(srna, "Closure Input Items", "");
8360 RNA_def_struct_sdna(srna, "bNode");
8361
8363 srna, "NodeClosureInputItem", "ClosureInputItemsAccessor");
8365 srna, "NodeClosureInputItem", "ClosureInputItemsAccessor");
8366}
8367
8369{
8370 PropertyRNA *prop;
8371
8372 StructRNA *srna = RNA_def_struct(brna, "NodeClosureOutputItem", nullptr);
8373 RNA_def_struct_ui_text(srna, "Closure Output Item", "");
8374 RNA_def_struct_sdna(srna, "NodeClosureOutputItem");
8375
8376 rna_def_node_item_array_socket_item_common(srna, "ClosureOutputItemsAccessor", true);
8377
8378 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8381 prop,
8382 nullptr,
8383 nullptr,
8384 "rna_Node_ItemArray_structure_type_itemf<ClosureOutputItemsAccessor>");
8386 prop,
8387 "Structure Type",
8388 "What kind of higher order types are expected to flow through this socket");
8390 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<ClosureOutputItemsAccessor>");
8391}
8392
8394{
8395 StructRNA *srna = RNA_def_struct(brna, "NodeClosureOutputItems", nullptr);
8396 RNA_def_struct_ui_text(srna, "Closure Output Items", "");
8397 RNA_def_struct_sdna(srna, "bNode");
8398
8400 srna, "NodeClosureOutputItem", "ClosureOutputItemsAccessor");
8402 srna, "NodeClosureOutputItem", "ClosureOutputItemsAccessor");
8403}
8404
8405static void def_closure_output(BlenderRNA *brna, StructRNA *srna)
8406{
8407 PropertyRNA *prop;
8408
8411
8414
8415 RNA_def_struct_sdna_from(srna, "NodeClosureOutput", "storage");
8416
8417 prop = RNA_def_property(srna, "input_items", PROP_COLLECTION, PROP_NONE);
8418 RNA_def_property_collection_sdna(prop, nullptr, "input_items.items", "input_items.items_num");
8419 RNA_def_property_struct_type(prop, "NodeClosureInputItem");
8420 RNA_def_property_srna(prop, "NodeClosureInputItems");
8421
8422 prop = RNA_def_property(srna, "output_items", PROP_COLLECTION, PROP_NONE);
8423 RNA_def_property_collection_sdna(prop, nullptr, "output_items.items", "output_items.items_num");
8424 RNA_def_property_struct_type(prop, "NodeClosureOutputItem");
8425 RNA_def_property_srna(prop, "NodeClosureOutputItems");
8426
8427 prop = RNA_def_property(srna, "active_input_index", PROP_INT, PROP_UNSIGNED);
8428 RNA_def_property_int_sdna(prop, nullptr, "input_items.active_index");
8429 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8432 RNA_def_property_update(prop, NC_NODE, nullptr);
8433
8434 prop = RNA_def_property(srna, "active_output_index", PROP_INT, PROP_UNSIGNED);
8435 RNA_def_property_int_sdna(prop, nullptr, "output_items.active_index");
8436 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8439 RNA_def_property_update(prop, NC_NODE, nullptr);
8440
8441 prop = RNA_def_property(srna, "define_signature", PROP_BOOLEAN, PROP_NONE);
8444 prop,
8445 "Define Signature",
8446 "This zone defines a closure signature that should be used by other nodes");
8449 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8450}
8451
8453{
8454 StructRNA *srna = RNA_def_struct(brna, "NodeGeometryCaptureAttributeItem", nullptr);
8455 RNA_def_struct_ui_text(srna, "Capture Attribute Item", "");
8456 RNA_def_struct_sdna(srna, "NodeGeometryAttributeCaptureItem");
8457
8458 rna_def_node_item_array_socket_item_common(srna, "CaptureAttributeItemsAccessor", false);
8459 PropertyRNA *prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
8462 prop, nullptr, nullptr, "rna_NodeGeometryCaptureAttributeItem_data_type_itemf");
8463 RNA_def_property_ui_text(prop, "Data Type", "");
8466 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<CaptureAttributeItemsAccessor>");
8467}
8468
8470{
8471 StructRNA *srna = RNA_def_struct(brna, "NodeGeometryCaptureAttributeItems", nullptr);
8472 RNA_def_struct_ui_text(srna, "Items", "Collection of capture attribute items");
8473 RNA_def_struct_sdna(srna, "bNode");
8474
8476 srna, "NodeGeometryCaptureAttributeItem", "CaptureAttributeItemsAccessor");
8478 srna, "NodeGeometryCaptureAttributeItem", "CaptureAttributeItemsAccessor");
8479}
8480
8482{
8483 PropertyRNA *prop;
8484
8487
8488 RNA_def_struct_sdna_from(srna, "NodeGeometryAttributeCapture", "storage");
8489
8490 prop = RNA_def_property(srna, "capture_items", PROP_COLLECTION, PROP_NONE);
8491 RNA_def_property_collection_sdna(prop, nullptr, "capture_items", "capture_items_num");
8492 RNA_def_property_struct_type(prop, "NodeGeometryCaptureAttributeItem");
8493 RNA_def_property_ui_text(prop, "Items", "");
8494 RNA_def_property_srna(prop, "NodeGeometryCaptureAttributeItems");
8495
8496 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8497 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8498 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8501 RNA_def_property_update(prop, NC_NODE, nullptr);
8502
8503 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
8504 RNA_def_property_struct_type(prop, "RepeatItem");
8506 "rna_Node_ItemArray_active_get<CaptureAttributeItemsAccessor>",
8507 "rna_Node_ItemArray_active_set<CaptureAttributeItemsAccessor>",
8508 nullptr,
8509 nullptr);
8511 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8512 RNA_def_property_update(prop, NC_NODE, nullptr);
8513
8514 prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE);
8515 RNA_def_property_ui_text(prop, "Domain", "Which domain to store the data in");
8518 prop, nullptr, nullptr, "rna_GeometryNodeAttributeDomain_attribute_domain_itemf");
8519 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8520}
8521
8523{
8524 StructRNA *srna;
8525 PropertyRNA *prop;
8526
8527 srna = RNA_def_struct(brna, "NodeEvaluateClosureInputItem", nullptr);
8528 RNA_def_struct_ui_text(srna, "Input Item", "");
8529
8530 rna_def_node_item_array_socket_item_common(srna, "EvaluateClosureInputItemsAccessor", true);
8531
8532 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8535 prop,
8536 nullptr,
8537 nullptr,
8538 "rna_Node_ItemArray_structure_type_itemf<EvaluateClosureInputItemsAccessor>");
8540 prop,
8541 "Structure Type",
8542 "What kind of higher order types are expected to flow through this socket");
8545 "rna_Node_ItemArray_item_update<EvaluateClosureInputItemsAccessor>");
8546}
8547
8549{
8550 StructRNA *srna;
8551
8552 srna = RNA_def_struct(brna, "NodeEvaluateClosureInputItems", nullptr);
8553 RNA_def_struct_ui_text(srna, "Input Items", "");
8554 RNA_def_struct_sdna(srna, "bNode");
8555
8557 srna, "NodeEvaluateClosureInputItem", "EvaluateClosureInputItemsAccessor");
8559 srna, "NodeEvaluateClosureInputItem", "EvaluateClosureInputItemsAccessor");
8560}
8561
8563{
8564 StructRNA *srna;
8565 PropertyRNA *prop;
8566
8567 srna = RNA_def_struct(brna, "NodeEvaluateClosureOutputItem", nullptr);
8568 RNA_def_struct_ui_text(srna, "Output Item", "");
8569
8570 rna_def_node_item_array_socket_item_common(srna, "EvaluateClosureOutputItemsAccessor", true);
8571
8572 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8575 prop,
8576 nullptr,
8577 nullptr,
8578 "rna_Node_ItemArray_structure_type_itemf<EvaluateClosureOutputItemsAccessor>");
8580 prop,
8581 "Structure Type",
8582 "What kind of higher order types are expected to flow through this socket");
8585 "rna_Node_ItemArray_item_update<EvaluateClosureOutputItemsAccessor>");
8586}
8587
8589{
8590 StructRNA *srna;
8591
8592 srna = RNA_def_struct(brna, "NodeEvaluateClosureOutputItems", nullptr);
8593 RNA_def_struct_ui_text(srna, "Output Items", "");
8594 RNA_def_struct_sdna(srna, "bNode");
8595
8597 srna, "NodeEvaluateClosureOutputItem", "EvaluateClosureOutputItemsAccessor");
8599 srna, "NodeEvaluateClosureOutputItem", "EvaluateClosureOutputItemsAccessor");
8600}
8601
8603{
8604 PropertyRNA *prop;
8605
8608
8611
8612 RNA_def_struct_sdna_from(srna, "NodeEvaluateClosure", "storage");
8613
8614 prop = RNA_def_property(srna, "input_items", PROP_COLLECTION, PROP_NONE);
8615 RNA_def_property_collection_sdna(prop, nullptr, "input_items.items", "input_items.items_num");
8616 RNA_def_property_struct_type(prop, "NodeEvaluateClosureInputItem");
8617 RNA_def_property_ui_text(prop, "Input Items", "");
8618 RNA_def_property_srna(prop, "NodeEvaluateClosureInputItems");
8619
8620 prop = RNA_def_property(srna, "output_items", PROP_COLLECTION, PROP_NONE);
8621 RNA_def_property_collection_sdna(prop, nullptr, "output_items.items", "output_items.items_num");
8622 RNA_def_property_struct_type(prop, "NodeEvaluateClosureOutputItem");
8623 RNA_def_property_ui_text(prop, "Output Items", "");
8624 RNA_def_property_srna(prop, "NodeEvaluateClosureOutputItems");
8625
8626 prop = RNA_def_property(srna, "active_input_index", PROP_INT, PROP_UNSIGNED);
8627 RNA_def_property_int_sdna(prop, nullptr, "input_items.active_index");
8628 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8631 RNA_def_property_update(prop, NC_NODE, nullptr);
8632
8633 prop = RNA_def_property(srna, "active_output_index", PROP_INT, PROP_UNSIGNED);
8634 RNA_def_property_int_sdna(prop, nullptr, "output_items.active_index");
8635 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8638 RNA_def_property_update(prop, NC_NODE, nullptr);
8639
8640 prop = RNA_def_property(srna, "define_signature", PROP_BOOLEAN, PROP_NONE);
8642 prop, nullptr, "flag", NODE_EVALUATE_CLOSURE_FLAG_DEFINE_SIGNATURE);
8644 prop,
8645 "Define Signature",
8646 "This node defines a closure signature that should be used by other nodes");
8649 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8650}
8651
8653{
8654 PropertyRNA *prop;
8655
8656 StructRNA *srna = RNA_def_struct(brna, "NodeGeometryBakeItem", nullptr);
8657 RNA_def_struct_ui_text(srna, "Bake Item", "");
8658
8659 rna_def_node_item_array_socket_item_common(srna, "BakeItemsAccessor", true);
8660
8661 prop = RNA_def_property(srna, "attribute_domain", PROP_ENUM, PROP_NONE);
8664 prop, nullptr, nullptr, "rna_GeometryNodeAttributeDomain_attribute_domain_itemf");
8666 prop,
8667 "Attribute Domain",
8668 "Domain where the field is captured if it is not already an attribute-field");
8671 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<BakeItemsAccessor>");
8672
8673 prop = RNA_def_property(srna, "is_attribute", PROP_BOOLEAN, PROP_NONE);
8675 RNA_def_property_ui_text(prop, "Is Attribute", "Bake item is an attribute stored on a geometry");
8677 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<BakeItemsAccessor>");
8678}
8679
8681{
8682 StructRNA *srna;
8683
8684 srna = RNA_def_struct(brna, "NodeGeometryBakeItems", nullptr);
8685 RNA_def_struct_sdna(srna, "bNode");
8686 RNA_def_struct_ui_text(srna, "Items", "Collection of bake items");
8687
8689 srna, "NodeGeometryBakeItem", "BakeItemsAccessor");
8690 rna_def_node_item_array_common_functions(srna, "NodeGeometryBakeItem", "BakeItemsAccessor");
8691}
8692
8693static void rna_def_geo_bake(BlenderRNA *brna, StructRNA *srna)
8694{
8695 PropertyRNA *prop;
8696
8699
8700 RNA_def_struct_sdna_from(srna, "NodeGeometryBake", "storage");
8701
8702 prop = RNA_def_property(srna, "bake_items", PROP_COLLECTION, PROP_NONE);
8703 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8704 RNA_def_property_struct_type(prop, "NodeGeometryBakeItem");
8705 RNA_def_property_ui_text(prop, "Items", "");
8706 RNA_def_property_srna(prop, "NodeGeometryBakeItems");
8707
8708 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8709 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8710 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8713 RNA_def_property_update(prop, NC_NODE, nullptr);
8714
8715 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
8716 RNA_def_property_struct_type(prop, "RepeatItem");
8718 "rna_Node_ItemArray_active_get<BakeItemsAccessor>",
8719 "rna_Node_ItemArray_active_set<BakeItemsAccessor>",
8720 nullptr,
8721 nullptr);
8724 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8725 RNA_def_property_update(prop, NC_NODE, nullptr);
8726}
8727
8729{
8730 StructRNA *srna;
8731 PropertyRNA *prop;
8732
8733 static const EnumPropertyItem type_items[] = {
8735 "SCALAR",
8736 0,
8737 "Scalar",
8738 "Rasterize a scalar attribute"},
8740 "VECTOR",
8741 0,
8742 "Vector",
8743 "Rasterize a vector attribute"},
8744 {0, nullptr, 0, nullptr, nullptr},
8745 };
8746
8747 srna = RNA_def_struct(brna, "NodeGeometryRasterizePointsItem", nullptr);
8748 RNA_def_struct_ui_text(srna, "Rasterize Points Item", "");
8749 RNA_def_struct_sdna(srna, "NodeGeometryRasterizePointsItem");
8750
8751 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
8753 prop, nullptr, nullptr, "rna_Node_ItemArray_item_name_set<RasterizePointsItemsAccessor>");
8754 RNA_def_property_ui_text(prop, "Name", "");
8755 RNA_def_struct_name_property(srna, prop);
8757 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<RasterizePointsItemsAccessor>");
8758
8759 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
8760 RNA_def_property_enum_items(prop, type_items);
8761 RNA_def_property_ui_text(prop, "Type", "");
8764 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<RasterizePointsItemsAccessor>");
8765}
8766
8768{
8769 StructRNA *srna;
8770 FunctionRNA *func;
8771 PropertyRNA *parm;
8772
8773 srna = RNA_def_struct(brna, "NodeGeometryRasterizePointsItems", nullptr);
8774 RNA_def_struct_sdna(srna, "bNode");
8775 RNA_def_struct_ui_text(srna, "Items", "Collection of grid items");
8776
8777 func = RNA_def_function(srna, "new", "rna_NodeGeometryRasterizePointsItems_new");
8778 RNA_def_function_ui_description(func, "Add an a new point attribute item");
8780 parm = RNA_def_string(func, "name", nullptr, MAX_NAME, "Name", "");
8782 /* return value */
8783 parm = RNA_def_pointer(func, "item", "NodeGeometryRasterizePointsItem", "Item", "New item");
8785 RNA_def_function_return(func, parm);
8786
8788 srna, "NodeGeometryRasterizePointsItem", "RasterizePointsItemsAccessor");
8789}
8790
8792{
8793 PropertyRNA *prop;
8794
8797
8798 RNA_def_struct_sdna_from(srna, "NodeGeometryRasterizePoints", "storage");
8799
8800 prop = RNA_def_property(srna, "rasterize_items", PROP_COLLECTION, PROP_NONE);
8801 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8802 RNA_def_property_struct_type(prop, "NodeGeometryRasterizePointsItem");
8803 RNA_def_property_ui_text(prop, "Items", "");
8804 RNA_def_property_srna(prop, "NodeGeometryRasterizePointsItems");
8805
8806 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8807 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8808 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8811 RNA_def_property_update(prop, NC_NODE, nullptr);
8812
8813 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
8814 RNA_def_property_struct_type(prop, "NodeGeometryRasterizePointsItem");
8816 "rna_Node_ItemArray_active_get<RasterizePointsItemsAccessor>",
8817 "rna_Node_ItemArray_active_set<RasterizePointsItemsAccessor>",
8818 nullptr,
8819 nullptr);
8821 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8822 RNA_def_property_update(prop, NC_NODE, nullptr);
8823}
8824
8826{
8827 PropertyRNA *prop;
8828
8829 StructRNA *srna = RNA_def_struct(brna, "NodeCombineBundleItem", nullptr);
8830 RNA_def_struct_ui_text(srna, "Combine Bundle Item", "");
8831
8832 rna_def_node_item_array_socket_item_common(srna, "CombineBundleItemsAccessor", true);
8833
8834 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8837 prop,
8838 nullptr,
8839 nullptr,
8840 "rna_Node_ItemArray_structure_type_itemf<CombineBundleItemsAccessor>");
8842 prop,
8843 "Structure Type",
8844 "What kind of higher order types are expected to flow through this socket");
8846 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<CombineBundleItemsAccessor>");
8847}
8848
8850{
8851 StructRNA *srna = RNA_def_struct(brna, "NodeCombineBundleItems", nullptr);
8852 RNA_def_struct_sdna(srna, "bNode");
8853 RNA_def_struct_ui_text(srna, "Items", "Collection of combine bundle items");
8854
8856 srna, "NodeCombineBundleItem", "CombineBundleItemsAccessor");
8858 srna, "NodeCombineBundleItem", "CombineBundleItemsAccessor");
8859}
8860
8861static void def_combine_bundle(BlenderRNA *brna, StructRNA *srna)
8862{
8863 PropertyRNA *prop;
8864
8867
8868 RNA_def_struct_sdna_from(srna, "NodeCombineBundle", "storage");
8869
8870 prop = RNA_def_property(srna, "bundle_items", PROP_COLLECTION, PROP_NONE);
8871 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8872 RNA_def_property_struct_type(prop, "NodeCombineBundleItem");
8873 RNA_def_property_ui_text(prop, "Items", "");
8874 RNA_def_property_srna(prop, "NodeCombineBundleItems");
8875
8876 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8877 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8878 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8881 RNA_def_property_update(prop, NC_NODE, nullptr);
8882
8883 prop = RNA_def_property(srna, "define_signature", PROP_BOOLEAN, PROP_NONE);
8886 prop,
8887 "Define Signature",
8888 "This node defines a bundle signature that should be used by other nodes");
8891 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8892}
8893
8895{
8896 PropertyRNA *prop;
8897
8898 StructRNA *srna = RNA_def_struct(brna, "NodeSeparateBundleItem", nullptr);
8899 RNA_def_struct_ui_text(srna, "Separate Bundle Item", "");
8900
8901 rna_def_node_item_array_socket_item_common(srna, "SeparateBundleItemsAccessor", true);
8902
8903 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
8906 prop,
8907 nullptr,
8908 nullptr,
8909 "rna_Node_ItemArray_structure_type_itemf<SeparateBundleItemsAccessor>");
8911 prop,
8912 "Structure Type",
8913 "What kind of higher order types are expected to flow through this socket");
8915 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<SeparateBundleItemsAccessor>");
8916}
8917
8919{
8920 StructRNA *srna = RNA_def_struct(brna, "NodeSeparateBundleItems", nullptr);
8921 RNA_def_struct_sdna(srna, "bNode");
8922 RNA_def_struct_ui_text(srna, "Items", "Collection of separate bundle items");
8923
8925 srna, "NodeSeparateBundleItem", "SeparateBundleItemsAccessor");
8927 srna, "NodeSeparateBundleItem", "SeparateBundleItemsAccessor");
8928}
8929
8931{
8932 PropertyRNA *prop;
8933
8936
8937 RNA_def_struct_sdna_from(srna, "NodeSeparateBundle", "storage");
8938
8939 prop = RNA_def_property(srna, "bundle_items", PROP_COLLECTION, PROP_NONE);
8940 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
8941 RNA_def_property_struct_type(prop, "NodeSeparateBundleItem");
8942 RNA_def_property_ui_text(prop, "Items", "");
8943 RNA_def_property_srna(prop, "NodeSeparateBundleItems");
8944
8945 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
8946 RNA_def_property_int_sdna(prop, nullptr, "active_index");
8947 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
8950 RNA_def_property_update(prop, NC_NODE, nullptr);
8951
8952 prop = RNA_def_property(srna, "define_signature", PROP_BOOLEAN, PROP_NONE);
8955 prop,
8956 "Define Signature",
8957 "This node defines a bundle signature that should be used by other nodes");
8960 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8961}
8962
8964{
8965 PropertyRNA *prop;
8966
8967 StructRNA *srna = RNA_def_struct(brna, "IndexSwitchItem", nullptr);
8968 RNA_def_struct_ui_text(srna, "Index Switch Item", "");
8969 RNA_def_struct_sdna(srna, "IndexSwitchItem");
8970
8971 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
8972 RNA_def_property_ui_range(prop, 0, INT32_MAX, 1, -1);
8973 RNA_def_property_ui_text(prop, "Identifier", "Consistent identifier used for the item");
8975 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
8976}
8977
8979{
8980 StructRNA *srna;
8981 FunctionRNA *func;
8982 PropertyRNA *parm;
8983
8984 srna = RNA_def_struct(brna, "NodeIndexSwitchItems", nullptr);
8985 RNA_def_struct_sdna(srna, "bNode");
8986 RNA_def_struct_ui_text(srna, "Items", "Collection of index_switch items");
8987
8988 func = RNA_def_function(srna, "new", "rna_NodeIndexSwitchItems_new");
8989 RNA_def_function_ui_description(func, "Add an item at the end");
8991 /* Return value. */
8992 parm = RNA_def_pointer(func, "item", "IndexSwitchItem", "Item", "New item");
8994 RNA_def_function_return(func, parm);
8995
8996 rna_def_node_item_array_common_functions(srna, "IndexSwitchItem", "IndexSwitchItemsAccessor");
8997}
8998
9000{
9001 PropertyRNA *prop;
9002
9005
9006 RNA_def_struct_sdna_from(srna, "NodeIndexSwitch", "storage");
9007
9008 prop = RNA_def_property(srna, "index_switch_items", PROP_COLLECTION, PROP_NONE);
9009 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9010 RNA_def_property_struct_type(prop, "IndexSwitchItem");
9011 RNA_def_property_ui_text(prop, "Items", "");
9012 RNA_def_property_srna(prop, "NodeIndexSwitchItems");
9013}
9014
9016{
9017 PropertyRNA *prop;
9018
9019 StructRNA *srna = RNA_def_struct(brna, "CombineListItem", nullptr);
9020 RNA_def_struct_ui_text(srna, "Combine List Item", "");
9021 RNA_def_struct_sdna(srna, "CombineListItem");
9022
9023 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
9024 RNA_def_property_ui_range(prop, 0, INT32_MAX, 1, -1);
9025 RNA_def_property_ui_text(prop, "Identifier", "Consistent identifier used for the item");
9027 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
9028}
9029
9031{
9032 StructRNA *srna;
9033 FunctionRNA *func;
9034 PropertyRNA *parm;
9035
9036 srna = RNA_def_struct(brna, "NodeCombineListItems", nullptr);
9037 RNA_def_struct_sdna(srna, "bNode");
9038 RNA_def_struct_ui_text(srna, "Items", "Collection of combine list items");
9039
9040 func = RNA_def_function(srna, "new", "rna_NodeCombineListItems_new");
9041 RNA_def_function_ui_description(func, "Add an item at the end");
9043
9044 parm = RNA_def_pointer(func, "item", "CombineListItem", "Item", "New item");
9045 RNA_def_function_return(func, parm);
9046
9047 rna_def_node_item_array_common_functions(srna, "CombineListItem", "CombineListItemsAccessor");
9048}
9049
9051{
9052 PropertyRNA *prop;
9053
9056
9057 RNA_def_struct_sdna_from(srna, "NodeCombineList", "storage");
9058
9059 prop = RNA_def_property(srna, "combine_list_items", PROP_COLLECTION, PROP_NONE);
9060 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9061 RNA_def_property_struct_type(prop, "CombineListItem");
9062 RNA_def_property_ui_text(prop, "Items", "");
9063 RNA_def_property_srna(prop, "NodeCombineListItems");
9064}
9065
9067{
9068 PropertyRNA *prop;
9069
9070 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeFieldToGridItem", nullptr);
9071 RNA_def_struct_ui_text(srna, "Field to Grid Item", "");
9072 RNA_def_struct_sdna(srna, "GeometryNodeFieldToGridItem");
9073
9074 rna_def_node_item_array_socket_item_common(srna, "FieldToGridItemsAccessor", false);
9075 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
9077 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeFieldToGridItem_data_type_itemf");
9078 RNA_def_property_ui_text(prop, "Data Type", "");
9081 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<FieldToGridItemsAccessor>");
9082
9083 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
9085}
9086
9088{
9089 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeFieldToGridItems", nullptr);
9090 RNA_def_struct_ui_text(srna, "Items", "Collection of field to grid items");
9091 RNA_def_struct_sdna(srna, "bNode");
9092
9094 srna, "GeometryNodeFieldToGridItem", "FieldToGridItemsAccessor");
9096 srna, "GeometryNodeFieldToGridItem", "FieldToGridItemsAccessor");
9097}
9098
9100{
9101 PropertyRNA *prop;
9102
9103 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeClosureToListItem", nullptr);
9104 RNA_def_struct_ui_text(srna, "Closure to List Item", "");
9105 RNA_def_struct_sdna(srna, "GeometryNodeClosureToListItem");
9106
9107 rna_def_node_item_array_socket_item_common(srna, "ClosureToListItemsAccessor", true);
9108
9109 prop = RNA_def_property(srna, "structure_type", PROP_ENUM, PROP_NONE);
9112 prop, nullptr, nullptr, "rna_GeometryNodeClosureToListItem_structure_type_itemf");
9113
9114 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
9116}
9117
9119{
9120 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeClosureToListItems", nullptr);
9121 RNA_def_struct_ui_text(srna, "Items", "Collection of closure to list items");
9122 RNA_def_struct_sdna(srna, "bNode");
9123
9125 srna, "GeometryNodeClosureToListItem", "ClosureToListItemsAccessor");
9127 srna, "GeometryNodeClosureToListItem", "ClosureToListItemsAccessor");
9128}
9129
9131{
9132 PropertyRNA *prop;
9133
9136
9137 RNA_def_struct_sdna_from(srna, "GeometryNodeClosureToList", "storage");
9138
9139 prop = RNA_def_property(srna, "list_items", PROP_COLLECTION, PROP_NONE);
9140 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9141 RNA_def_property_struct_type(prop, "GeometryNodeClosureToListItem");
9142 RNA_def_property_ui_text(prop, "Items", "");
9143 RNA_def_property_srna(prop, "GeometryNodeClosureToListItems");
9144
9145 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
9146 RNA_def_property_int_sdna(prop, nullptr, "active_index");
9147 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9150 RNA_def_property_update(prop, NC_NODE, nullptr);
9151
9152 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
9153 RNA_def_property_struct_type(prop, "RepeatItem");
9155 "rna_Node_ItemArray_active_get<ClosureToListItemsAccessor>",
9156 "rna_Node_ItemArray_active_set<ClosureToListItemsAccessor>",
9157 nullptr,
9158 nullptr);
9160 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9161 RNA_def_property_update(prop, NC_NODE, nullptr);
9162}
9163
9165{
9166 PropertyRNA *prop;
9167
9170
9171 RNA_def_struct_sdna_from(srna, "GeometryNodeFieldToGrid", "storage");
9172
9173 prop = RNA_def_property(srna, "grid_items", PROP_COLLECTION, PROP_NONE);
9174 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9175 RNA_def_property_struct_type(prop, "GeometryNodeFieldToGridItem");
9176 RNA_def_property_ui_text(prop, "Items", "");
9177 RNA_def_property_srna(prop, "GeometryNodeFieldToGridItems");
9178
9179 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
9180 RNA_def_property_int_sdna(prop, nullptr, "active_index");
9181 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9184 RNA_def_property_update(prop, NC_NODE, nullptr);
9185
9186 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
9187 RNA_def_property_struct_type(prop, "RepeatItem");
9189 "rna_Node_ItemArray_active_get<FieldToGridItemsAccessor>",
9190 "rna_Node_ItemArray_active_set<FieldToGridItemsAccessor>",
9191 nullptr,
9192 nullptr);
9194 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9195 RNA_def_property_update(prop, NC_NODE, nullptr);
9196
9197 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
9199 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeFieldToGridItem_data_type_itemf");
9200 RNA_def_property_ui_text(prop, "Data Type", "Data type for topology grid");
9202 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9203}
9204
9206{
9207 PropertyRNA *prop;
9208
9209 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeFieldToListItem", nullptr);
9210 RNA_def_struct_ui_text(srna, "Field to List Item", "");
9211 RNA_def_struct_sdna(srna, "GeometryNodeFieldToListItem");
9212
9213 rna_def_node_item_array_socket_item_common(srna, "FieldToListItemsAccessor", true);
9214
9215 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
9217}
9218
9220{
9221 StructRNA *srna = RNA_def_struct(brna, "GeometryNodeFieldToListItems", nullptr);
9222 RNA_def_struct_ui_text(srna, "Items", "Collection of field to list items");
9223 RNA_def_struct_sdna(srna, "bNode");
9224
9226 srna, "GeometryNodeFieldToListItem", "FieldToListItemsAccessor");
9228 srna, "GeometryNodeFieldToListItem", "FieldToListItemsAccessor");
9229}
9230
9232{
9233 PropertyRNA *prop;
9234
9237
9238 RNA_def_struct_sdna_from(srna, "GeometryNodeFieldToList", "storage");
9239
9240 prop = RNA_def_property(srna, "list_items", PROP_COLLECTION, PROP_NONE);
9241 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9242 RNA_def_property_struct_type(prop, "GeometryNodeFieldToListItem");
9243 RNA_def_property_ui_text(prop, "Items", "");
9244 RNA_def_property_srna(prop, "GeometryNodeFieldToListItems");
9245
9246 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
9247 RNA_def_property_int_sdna(prop, nullptr, "active_index");
9248 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9251 RNA_def_property_update(prop, NC_NODE, nullptr);
9252
9253 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
9254 RNA_def_property_struct_type(prop, "GeometryNodeFieldToListItem");
9256 "rna_Node_ItemArray_active_get<FieldToListItemsAccessor>",
9257 "rna_Node_ItemArray_active_set<FieldToListItemsAccessor>",
9258 nullptr,
9259 nullptr);
9261 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9262 RNA_def_property_update(prop, NC_NODE, nullptr);
9263}
9264
9266{
9267 StructRNA *srna;
9268
9269 srna = RNA_def_struct(brna, "NodeFunctionFormatStringItem", nullptr);
9270 RNA_def_struct_ui_text(srna, "Format String Item", "");
9271
9272 rna_def_node_item_array_socket_item_common(srna, "FormatStringItemsAccessor", true);
9273}
9274
9276{
9277 StructRNA *srna;
9278
9279 srna = RNA_def_struct(brna, "NodeFunctionFormatStringItems", nullptr);
9280 RNA_def_struct_sdna(srna, "bNode");
9281 RNA_def_struct_ui_text(srna, "Items", "Collection of format string items");
9282
9284 srna, "NodeFunctionFormatStringItem", "FormatStringItemsAccessor");
9286 srna, "NodeFunctionFormatStringItem", "FormatStringItemsAccessor");
9287}
9288
9290{
9291 PropertyRNA *prop;
9292
9295
9296 RNA_def_struct_sdna_from(srna, "NodeFunctionFormatString", "storage");
9297
9298 prop = RNA_def_property(srna, "format_items", PROP_COLLECTION, PROP_NONE);
9299 RNA_def_property_collection_sdna(prop, nullptr, "items", "items_num");
9300 RNA_def_property_struct_type(prop, "NodeFunctionFormatStringItem");
9301 RNA_def_property_ui_text(prop, "Items", "");
9302 RNA_def_property_srna(prop, "NodeFunctionFormatStringItems");
9303
9304 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
9305 RNA_def_property_int_sdna(prop, nullptr, "active_index");
9306 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9309 RNA_def_property_update(prop, NC_NODE, nullptr);
9310}
9311
9313{
9314 PropertyRNA *prop;
9315
9316 RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSelectHandles", "storage");
9317
9318 prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
9319 RNA_def_property_enum_sdna(prop, nullptr, "handle_type");
9320 RNA_def_property_ui_text(prop, "Handle Type", "");
9323 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9324
9325 prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
9329 RNA_def_property_ui_text(prop, "Mode", "Whether to check the type of left and right handles");
9330 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9331}
9332
9333static void def_fn_rotate_euler(BlenderRNA * /*brna*/, StructRNA *srna)
9334{
9335 static const EnumPropertyItem type_items[] = {
9337 "AXIS_ANGLE",
9338 ICON_NONE,
9339 "Axis Angle",
9340 "Rotate around an axis by an angle"},
9342 "EULER",
9343 ICON_NONE,
9344 "Euler",
9345 "Rotate around the X, Y, and Z axes"},
9346 {0, nullptr, 0, nullptr, nullptr},
9347 };
9348
9349 static const EnumPropertyItem space_items[] = {
9351 "OBJECT",
9352 ICON_NONE,
9353 "Object",
9354 "Rotate the input rotation in the local space of the object"},
9356 "LOCAL",
9357 ICON_NONE,
9358 "Local",
9359 "Rotate the input rotation in its local space"},
9360 {0, nullptr, 0, nullptr, nullptr},
9361 };
9362
9363 PropertyRNA *prop;
9364
9365 prop = RNA_def_property(srna, "rotation_type", PROP_ENUM, PROP_NONE);
9366 RNA_def_property_enum_sdna(prop, nullptr, "custom1");
9367 RNA_def_property_enum_items(prop, type_items);
9368 RNA_def_property_ui_text(prop, "Type", "Method used to describe the rotation");
9369 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9370
9371 prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
9372 RNA_def_property_enum_sdna(prop, nullptr, "custom2");
9373 RNA_def_property_enum_items(prop, space_items);
9374 RNA_def_property_ui_text(prop, "Space", "Base orientation for rotation");
9375 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9376}
9377
9378static void def_geo_sample_index(BlenderRNA * /*brna*/, StructRNA *srna)
9379{
9380 PropertyRNA *prop;
9381
9382 RNA_def_struct_sdna_from(srna, "NodeGeometrySampleIndex", "storage");
9383
9384 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
9387 prop, nullptr, nullptr, "rna_GeometryNodeAttributeType_type_with_socket_itemf");
9389 RNA_def_property_ui_text(prop, "Data Type", "");
9391 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9392
9393 prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE);
9396 prop, nullptr, nullptr, "rna_GeometryNodeAttributeDomain_attribute_domain_itemf");
9398 RNA_def_property_ui_text(prop, "Domain", "");
9399 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9400
9401 prop = RNA_def_property(srna, "clamp", PROP_BOOLEAN, PROP_NONE);
9403 "Clamp",
9404 "Clamp the indices to the size of the attribute domain instead of "
9405 "outputting a default value for invalid indices");
9406 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9407}
9408
9409static void def_geo_input_material(BlenderRNA * /*brna*/, StructRNA *srna)
9410{
9411 PropertyRNA *prop;
9412
9413 prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
9414 RNA_def_property_pointer_sdna(prop, nullptr, "id");
9415 RNA_def_property_struct_type(prop, "Material");
9418 RNA_def_property_ui_text(prop, "Material", "");
9419 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9420}
9421
9422static void def_geo_input_collection(BlenderRNA * /*brna*/, StructRNA *srna)
9423{
9424 PropertyRNA *prop;
9425
9426 prop = RNA_def_property(srna, "collection", PROP_POINTER, PROP_NONE);
9427 RNA_def_property_pointer_sdna(prop, nullptr, "id");
9428 RNA_def_property_struct_type(prop, "Collection");
9431 RNA_def_property_ui_text(prop, "Collection", "");
9432 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9433}
9434
9435static void def_geo_input_font(BlenderRNA * /*brna*/, StructRNA *srna)
9436{
9437 PropertyRNA *prop;
9438
9439 prop = RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE);
9440 RNA_def_property_pointer_sdna(prop, nullptr, "id");
9441 RNA_def_property_struct_type(prop, "VectorFont");
9444 RNA_def_property_ui_text(prop, "Font", "");
9445 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9446}
9447
9448static void def_geo_input_normal(BlenderRNA * /*brna*/, StructRNA *srna)
9449{
9450 PropertyRNA *prop = RNA_def_property(srna, "legacy_corner_normals", PROP_BOOLEAN, PROP_NONE);
9451 RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
9453 prop,
9454 "Flat Corner Normals",
9455 "Always use face normals for the face corner domain, matching old behavior of the node");
9456 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9457}
9458
9459static void def_geo_input_object(BlenderRNA * /*brna*/, StructRNA *srna)
9460{
9461 PropertyRNA *prop;
9462
9463 prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
9464 RNA_def_property_pointer_sdna(prop, nullptr, "id");
9465 RNA_def_property_struct_type(prop, "Object");
9468 RNA_def_property_ui_text(prop, "Object", "");
9469 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9470}
9471
9472static void def_geo_image(BlenderRNA * /*brna*/, StructRNA *srna)
9473{
9474 PropertyRNA *prop;
9475
9476 prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
9477 RNA_def_property_pointer_sdna(prop, nullptr, "id");
9478 RNA_def_property_struct_type(prop, "Image");
9480 RNA_def_property_ui_text(prop, "Image", "");
9481 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9483 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
9484}
9485
9487{
9488 PropertyRNA *prop;
9489
9490 StructRNA *srna = RNA_def_struct(brna, "NodeEnumItem", nullptr);
9491 RNA_def_struct_ui_text(srna, "Enum Item", "");
9492
9493 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
9495 prop, nullptr, nullptr, "rna_Node_ItemArray_item_name_set<MenuSwitchItemsAccessor>");
9496 RNA_def_property_ui_text(prop, "Name", "");
9497 RNA_def_struct_name_property(srna, prop);
9499 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<MenuSwitchItemsAccessor>");
9500
9501 prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
9502 RNA_def_property_string_sdna(prop, nullptr, "description");
9503 RNA_def_property_ui_text(prop, "Description", "");
9505 prop, NC_NODE | NA_EDITED, "rna_Node_ItemArray_item_update<MenuSwitchItemsAccessor>");
9506}
9507
9509{
9510 StructRNA *srna;
9511 PropertyRNA *parm;
9512 FunctionRNA *func;
9513
9514 srna = RNA_def_struct(brna, "NodeMenuSwitchItems", nullptr);
9515 RNA_def_struct_sdna(srna, "bNode");
9517 srna, "Enum Definition Items", "Collection of items that make up an enum");
9518
9519 func = RNA_def_function(srna, "new", "rna_NodeMenuSwitchItems_new");
9520 RNA_def_function_ui_description(func, "Add an a new enum item");
9522 parm = RNA_def_string(func, "name", nullptr, MAX_NAME, "Name", "");
9524 /* return value */
9525 parm = RNA_def_pointer(func, "item", "NodeEnumItem", "Item", "New item");
9527 RNA_def_function_return(func, parm);
9528
9529 rna_def_node_item_array_common_functions(srna, "NodeEnumItem", "MenuSwitchItemsAccessor");
9530}
9531
9533{
9534 PropertyRNA *prop;
9535
9538
9539 RNA_def_struct_sdna_from(srna, "NodeMenuSwitch", "storage");
9540
9541 prop = RNA_def_property(srna, "enum_items", PROP_COLLECTION, PROP_NONE);
9543 prop, nullptr, "enum_definition.items_array", "enum_definition.items_num");
9544 RNA_def_property_struct_type(prop, "NodeEnumItem");
9545 RNA_def_property_ui_text(prop, "Items", "");
9546 RNA_def_property_srna(prop, "NodeMenuSwitchItems");
9547
9548 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
9549 RNA_def_property_int_sdna(prop, nullptr, "enum_definition.active_index");
9550 RNA_def_property_ui_text(prop, "Active Item Index", "Index of the active item");
9552 RNA_def_property_update(prop, NC_NODE, nullptr);
9553
9554 prop = RNA_def_property(srna, "active_item", PROP_POINTER, PROP_NONE);
9555 RNA_def_property_struct_type(prop, "NodeEnumItem");
9557 "rna_Node_ItemArray_active_get<MenuSwitchItemsAccessor>",
9558 "rna_Node_ItemArray_active_set<MenuSwitchItemsAccessor>",
9559 nullptr,
9560 nullptr);
9562 RNA_def_property_ui_text(prop, "Active Item", "Active item");
9563 RNA_def_property_update(prop, NC_NODE, nullptr);
9564
9565 /* This exists only for backward compatibility. */
9566 prop = RNA_def_property(srna, "enum_definition", PROP_POINTER, PROP_NONE);
9567 RNA_def_property_struct_type(prop, "Node");
9569 prop, "rna_NodeMenuSwitch_enum_definition_get", nullptr, nullptr, nullptr);
9572 "Enum Definition (deprecated)",
9573 "The enum definition can now be accessed directly on the node. This "
9574 "exists for backward compatibility.");
9575}
9576
9578{
9579 StructRNA *srna;
9580
9581 srna = RNA_def_struct(brna, "ShaderNode", "NodeInternal");
9582 RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node");
9583 RNA_def_struct_sdna(srna, "bNode");
9584 RNA_def_struct_register_funcs(srna, "rna_ShaderNode_register", "rna_Node_unregister", nullptr);
9585}
9586
9588{
9589 StructRNA *srna;
9590
9591 srna = RNA_def_struct(brna, "CompositorNode", "NodeInternal");
9592 RNA_def_struct_ui_text(srna, "Compositor Node", "");
9593 RNA_def_struct_sdna(srna, "bNode");
9595 srna, "rna_CompositorNode_register", "rna_Node_unregister", nullptr);
9596
9598}
9599
9601{
9602 StructRNA *srna;
9603
9604 srna = RNA_def_struct(brna, "TextureNode", "NodeInternal");
9605 RNA_def_struct_ui_text(srna, "Texture Node", "");
9606 RNA_def_struct_sdna(srna, "bNode");
9607 RNA_def_struct_register_funcs(srna, "rna_TextureNode_register", "rna_Node_unregister", nullptr);
9608}
9609
9611{
9612 StructRNA *srna;
9613
9614 srna = RNA_def_struct(brna, "GeometryNode", "NodeInternal");
9615 RNA_def_struct_ui_text(srna, "Geometry Node", "");
9616 RNA_def_struct_sdna(srna, "bNode");
9617 RNA_def_struct_register_funcs(srna, "rna_GeometryNode_register", "rna_Node_unregister", nullptr);
9618}
9619
9621{
9622 StructRNA *srna;
9623
9624 srna = RNA_def_struct(brna, "FunctionNode", "NodeInternal");
9625 RNA_def_struct_ui_text(srna, "Function Node", "");
9626 RNA_def_struct_sdna(srna, "bNode");
9627 RNA_def_struct_register_funcs(srna, "rna_FunctionNode_register", "rna_Node_unregister", nullptr);
9628}
9629
9630/* -------------------------------------------------------------------------- */
9631
9632static void def_reroute(BlenderRNA * /*brna*/, StructRNA *srna)
9633{
9634 RNA_def_struct_sdna_from(srna, "NodeReroute", "storage");
9635
9636 PropertyRNA *prop = RNA_def_property(srna, "socket_idname", PROP_STRING, PROP_NONE);
9637 RNA_def_property_string_sdna(prop, nullptr, "type_idname");
9638 RNA_def_property_string_funcs(prop, nullptr, nullptr, "rna_reroute_node_socket_type_set");
9639 RNA_def_property_ui_text(prop, "Type of socket", "");
9640 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9641}
9642
9643static void def_implicit_conversion(BlenderRNA * /*brna*/, StructRNA *srna)
9644{
9645 PropertyRNA *prop;
9646
9647 RNA_def_struct_sdna_from(srna, "NodeImplicitConversion", "storage");
9648
9649 prop = RNA_def_property(srna, "socket_idname", PROP_STRING, PROP_NONE);
9650 RNA_def_property_string_sdna(prop, nullptr, "type_idname");
9652 prop, nullptr, nullptr, "rna_implicit_conversion_node_socket_type_set");
9653 RNA_def_property_ui_text(prop, "Type of socket", "");
9654 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9655
9656 prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE);
9659 "rna_NodeImplicitConversion_data_type_get",
9660 "rna_NodeImplicitConversion_data_type_set",
9661 "rna_NodeImplicitConversion_data_type_itemf");
9663 RNA_def_property_ui_text(prop, "Data Type", "");
9665 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update");
9666}
9667
9668static void def_comment(BlenderRNA * /*brna*/, StructRNA *srna)
9669{
9670 PropertyRNA *prop;
9671
9672 RNA_def_struct_sdna_from(srna, "NodeComment", "storage");
9673
9674 prop = RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
9675 RNA_def_property_ui_text(prop, "Text", "Text to show in the node");
9677 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
9678}
9679
9681{
9682 StructRNA *srna;
9683 PropertyRNA *prop, *parm;
9684 FunctionRNA *func;
9685
9686 srna = RNA_def_struct(brna, "NodeInternalSocketTemplate", nullptr);
9687 RNA_def_struct_ui_text(srna, "Socket Template", "Type and default value of a node socket");
9688
9689 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
9691 "rna_NodeInternalSocketTemplate_name_get",
9692 "rna_NodeInternalSocketTemplate_name_length",
9693 nullptr);
9694 RNA_def_property_ui_text(prop, "Name", "Name of the socket");
9696
9697 prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
9699 "rna_NodeInternalSocketTemplate_identifier_get",
9700 "rna_NodeInternalSocketTemplate_identifier_length",
9701 nullptr);
9702 RNA_def_property_ui_text(prop, "Identifier", "Identifier of the socket");
9704
9705 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
9706 RNA_def_property_enum_funcs(prop, "rna_NodeInternalSocketTemplate_type_get", nullptr, nullptr);
9708 RNA_def_property_ui_text(prop, "Type", "Data type of the socket");
9710
9711 /* XXX Workaround: Registered functions are not exposed in python by bpy,
9712 * it expects them to be registered from python and use the native implementation.
9713 *
9714 * However, the standard node types are not registering these functions from python,
9715 * so in order to call them in py scripts we need to overload and
9716 * replace them with plain C callbacks.
9717 * This type provides a usable basis for node types defined in C.
9718 */
9719
9720 srna = RNA_def_struct(brna, "NodeInternal", "Node");
9721 RNA_def_struct_sdna(srna, "bNode");
9722
9723 /* poll */
9724 func = RNA_def_function(srna, "poll", "rna_NodeInternal_poll");
9726 func, "If non-null output is returned, the node type can be added to the tree");
9728 RNA_def_function_return(func, RNA_def_boolean(func, "visible", false, "", ""));
9729 parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", "");
9731
9732 func = RNA_def_function(srna, "poll_instance", "rna_NodeInternal_poll_instance");
9734 func, "If non-null output is returned, the node can be added to the tree");
9735 RNA_def_function_return(func, RNA_def_boolean(func, "visible", false, "", ""));
9736 parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", "");
9738
9739 /* update */
9740 func = RNA_def_function(srna, "update", "rna_NodeInternal_update");
9742 func, "Update on node graph topology changes (adding or removing nodes and links)");
9744
9745 /* draw buttons */
9746 func = RNA_def_function(srna, "draw_buttons", "rna_NodeInternal_draw_buttons");
9747 RNA_def_function_ui_description(func, "Draw node buttons");
9749 parm = RNA_def_pointer(func, "context", "Context", "", "");
9751 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
9752 RNA_def_property_struct_type(parm, "UILayout");
9753 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
9755
9756 /* draw buttons extended */
9757 func = RNA_def_function(srna, "draw_buttons_ext", "rna_NodeInternal_draw_buttons_ext");
9758 RNA_def_function_ui_description(func, "Draw node buttons in the sidebar");
9760 parm = RNA_def_pointer(func, "context", "Context", "", "");
9762 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
9763 RNA_def_property_struct_type(parm, "UILayout");
9764 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
9766}
9767
9768static void rna_def_node_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int in_out)
9769{
9770 StructRNA *srna;
9771 PropertyRNA *parm;
9772 FunctionRNA *func;
9773 const char *structtype = (in_out == SOCK_IN ? "NodeInputs" : "NodeOutputs");
9774 const char *uiname = (in_out == SOCK_IN ? "Node Inputs" : "Node Outputs");
9775 const char *newfunc = (in_out == SOCK_IN ? "rna_Node_inputs_new" : "rna_Node_outputs_new");
9776 const char *clearfunc = (in_out == SOCK_IN ? "rna_Node_inputs_clear" : "rna_Node_outputs_clear");
9777 const char *movefunc = (in_out == SOCK_IN ? "rna_Node_inputs_move" : "rna_Node_outputs_move");
9778
9779 RNA_def_property_srna(cprop, structtype);
9780 srna = RNA_def_struct(brna, structtype, nullptr);
9781 RNA_def_struct_sdna(srna, "bNode");
9782 RNA_def_struct_ui_text(srna, uiname, "Collection of Node Sockets");
9783
9784 func = RNA_def_function(srna, "new", newfunc);
9785 RNA_def_function_ui_description(func, "Add a socket to this node");
9787 parm = RNA_def_string(func, "type", nullptr, MAX_NAME, "Type", "Data type");
9789 parm = RNA_def_string(func, "name", nullptr, MAX_NAME, "Name", "");
9791 RNA_def_string(func, "identifier", nullptr, MAX_NAME, "Identifier", "Unique socket identifier");
9793 func, "use_multi_input", false, "", "Make the socket multi-input (valid for inputs only)");
9794 /* return value */
9795 parm = RNA_def_pointer(func, "socket", "NodeSocket", "", "New socket");
9797 RNA_def_function_return(func, parm);
9798
9799 func = RNA_def_function(srna, "remove", "rna_Node_socket_remove");
9800 RNA_def_function_ui_description(func, "Remove a socket from this node");
9802 parm = RNA_def_pointer(func, "socket", "NodeSocket", "", "The socket to remove");
9804
9805 func = RNA_def_function(srna, "clear", clearfunc);
9806 RNA_def_function_ui_description(func, "Remove all sockets from this node");
9808
9809 func = RNA_def_function(srna, "move", movefunc);
9810 RNA_def_function_ui_description(func, "Move a socket to another position");
9812 parm = RNA_def_int(
9813 func, "from_index", -1, 0, INT_MAX, "From Index", "Index of the socket to move", 0, 10000);
9815 parm = RNA_def_int(
9816 func, "to_index", -1, 0, INT_MAX, "To Index", "Target index for the socket", 0, 10000);
9818}
9819
9821{
9822 StructRNA *srna;
9823 PropertyRNA *prop;
9824
9825 srna = RNA_def_struct(brna, "NodePanelState", nullptr);
9826 RNA_def_struct_sdna(srna, "bNodePanelState");
9827 RNA_def_struct_ui_text(srna, "Node Panel State", "Expansion state of a panel in a node");
9828
9829 prop = RNA_def_property(srna, "identifier", PROP_INT, PROP_NONE);
9830 RNA_def_property_int_sdna(prop, nullptr, "identifier");
9833 prop, "Identifier", "Unique identifier matching the panel's persistent_uid");
9834
9835 prop = RNA_def_property(srna, "is_collapsed", PROP_BOOLEAN, PROP_NONE);
9837 RNA_def_property_ui_text(prop, "Is Collapsed", "Whether the panel is collapsed");
9839 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
9840}
9841
9842static void rna_def_node(BlenderRNA *brna)
9843{
9844 StructRNA *srna;
9845 PropertyRNA *prop;
9846 FunctionRNA *func;
9847 PropertyRNA *parm;
9848
9849 static const EnumPropertyItem warning_propagation_items[] = {
9851 "ALL",
9852 0,
9853 "All Messages",
9854 "Propagate every info, error, and warning message upstream"},
9856 "ERRORS_AND_WARNINGS",
9857 0,
9858 "Errors and Warnings",
9859 "Propagate only error and warning messages upstream"},
9861 "ERRORS",
9862 0,
9863 "Errors",
9864 "Propagate only error messages upstream"},
9865 {NODE_WARNING_PROPAGATION_NONE, "NONE", 0, "None", "Do not propagate any messages upstream"},
9866 {0, nullptr, 0, nullptr, nullptr},
9867 };
9868
9869 srna = RNA_def_struct(brna, "Node", nullptr);
9870 RNA_def_struct_ui_text(srna, "Node", "Node in a node tree");
9871 RNA_def_struct_sdna(srna, "bNode");
9872 RNA_def_struct_ui_icon(srna, ICON_NODE);
9873 RNA_def_struct_refine_func(srna, "rna_Node_refine");
9874 RNA_def_struct_path_func(srna, "rna_Node_path");
9875 RNA_def_struct_register_funcs(srna, "rna_Node_register", "rna_Node_unregister", nullptr);
9876 RNA_def_struct_idprops_func(srna, "rna_Node_idprops");
9877 RNA_def_struct_system_idprops_func(srna, "rna_Node_system_idprops");
9878
9879 prop = RNA_def_property(srna, "type", PROP_STRING, PROP_NONE);
9880 RNA_def_property_string_funcs(prop, "rna_node_type_get", "rna_node_type_length", nullptr);
9883 prop, "Type", "Legacy unique node type identifier, redundant with bl_idname property");
9884
9885 prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
9886 RNA_def_property_array(prop, 2);
9887 RNA_def_property_float_funcs(prop, "rna_Node_location_get", "rna_Node_location_set", nullptr);
9888 RNA_def_property_range(prop, -1000000.0f, 1000000.0f);
9889 RNA_def_property_ui_text(prop, "Location", "Location of the node within its parent frame");
9890 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
9891
9892 prop = RNA_def_property(srna, "location_absolute", PROP_FLOAT, PROP_XYZ);
9893 RNA_def_property_float_sdna(prop, nullptr, "location");
9894 RNA_def_property_array(prop, 2);
9895 RNA_def_property_range(prop, -1000000.0f, 1000000.0f);
9896 RNA_def_property_ui_text(prop, "Absolute Location", "Location of the node in the entire canvas");
9897 RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
9898
9899 prop = RNA_def_property(srna, "width", PROP_FLOAT, PROP_XYZ);
9900 RNA_def_property_float_sdna(prop, nullptr, "width");
9901 RNA_def_property_float_funcs(prop, nullptr, nullptr, "rna_Node_width_range");
9902 RNA_def_property_ui_text(prop, "Width", "Width of the node");
9903 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
9904
9905 prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_XYZ);
9906 RNA_def_property_float_sdna(prop, nullptr, "height");
9907 RNA_def_property_float_funcs(prop, nullptr, nullptr, "rna_Node_height_range");
9909 prop,
9910 "Height",
9911 "Height of the node. This property holds true data only under certain circumstances, "
9912 "e.g. for a Frame node after the node graph was displayed. For most types of nodes, "
9913 "the displayed height is based on the node's contents and not reflected in this property.");
9914 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
9915
9916 prop = RNA_def_property(srna, "dimensions", PROP_FLOAT, PROP_XYZ_LENGTH);
9917 RNA_def_property_array(prop, 2);
9918 RNA_def_property_float_funcs(prop, "rna_Node_dimensions_get", nullptr, nullptr);
9920 prop, "Dimensions", "Absolute bounding box dimensions of the node after it was displayed");
9922
9923 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
9924 RNA_def_property_ui_text(prop, "Name", "Unique node identifier");
9925 RNA_def_struct_name_property(srna, prop);
9926 RNA_def_property_string_funcs(prop, nullptr, nullptr, "rna_Node_name_set");
9927 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
9928
9929 prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
9930 RNA_def_property_string_sdna(prop, nullptr, "label");
9931 RNA_def_property_ui_text(prop, "Label", "Optional custom node label");
9932 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
9933
9934 prop = RNA_def_property(srna, "inputs", PROP_COLLECTION, PROP_NONE);
9935 RNA_def_property_collection_sdna(prop, nullptr, "inputs", nullptr);
9937 nullptr,
9938 nullptr,
9939 nullptr,
9940 nullptr,
9941 nullptr,
9942 nullptr,
9943 "rna_NodeInputs_lookup_string",
9944 nullptr);
9945 RNA_def_property_struct_type(prop, "NodeSocket");
9948 RNA_def_property_ui_text(prop, "Inputs", "");
9949 rna_def_node_sockets_api(brna, prop, SOCK_IN);
9950
9951 prop = RNA_def_property(srna, "outputs", PROP_COLLECTION, PROP_NONE);
9952 RNA_def_property_collection_sdna(prop, nullptr, "outputs", nullptr);
9954 nullptr,
9955 nullptr,
9956 nullptr,
9957 nullptr,
9958 nullptr,
9959 nullptr,
9960 "rna_NodeOutputs_lookup_string",
9961 nullptr);
9962 RNA_def_property_struct_type(prop, "NodeSocket");
9965 RNA_def_property_ui_text(prop, "Outputs", "");
9967
9968 prop = RNA_def_property(srna, "panel_states", PROP_COLLECTION, PROP_NONE);
9969 RNA_def_property_collection_sdna(prop, nullptr, "panel_states_array", "num_panel_states");
9970 RNA_def_property_struct_type(prop, "NodePanelState");
9972 RNA_def_property_ui_text(prop, "Panel States", "Expansion state of each panel in the node");
9973
9974 prop = RNA_def_property(srna, "internal_links", PROP_COLLECTION, PROP_NONE);
9976 "rna_Node_internal_links_begin",
9977 "rna_iterator_array_next",
9978 "rna_iterator_array_end",
9979 "rna_iterator_array_get",
9980 nullptr,
9981 nullptr,
9982 nullptr,
9983 nullptr);
9984 RNA_def_property_struct_type(prop, "NodeInternalLink");
9986 prop, "Internal Links", "Internal input-to-output connections for muting");
9987
9988 prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
9989 RNA_def_property_pointer_sdna(prop, nullptr, "parent");
9991 prop, nullptr, "rna_Node_parent_set", nullptr, "rna_Node_parent_poll");
9995 RNA_def_property_struct_type(prop, "Node");
9996 RNA_def_property_ui_text(prop, "Parent", "Parent this node is attached to, e.g. a Frame node");
9997
9998 prop = RNA_def_property(srna, "warning_propagation", PROP_ENUM, PROP_NONE);
9999 RNA_def_property_enum_items(prop, warning_propagation_items);
10001 prop,
10002 "Warning Propagation",
10003 "The kinds of messages that should be propagated from this node to the parent group node");
10004 RNA_def_property_update(prop, 0, "rna_Node_update");
10005
10006 prop = RNA_def_property(srna, "use_custom_color", PROP_BOOLEAN, PROP_NONE);
10007 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_CUSTOM_COLOR);
10009 RNA_def_property_ui_text(prop, "Custom Color", "Use custom color for the node");
10010 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
10011
10012 prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
10013 RNA_def_property_array(prop, 3);
10014 RNA_def_property_range(prop, 0.0f, 1.0f);
10015 RNA_def_property_ui_text(prop, "Color", "Custom color of the node body");
10016 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
10017
10018 prop = RNA_def_property(srna, "color_tag", PROP_ENUM, PROP_NONE);
10020 RNA_def_property_enum_funcs(prop, "rna_Node_color_tag_get", nullptr, nullptr);
10021 RNA_def_property_ui_text(prop, "Color Tag", "Node header color tag");
10023
10024 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
10025 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SELECT);
10026 RNA_def_property_boolean_funcs(prop, nullptr, "rna_Node_select_set");
10027 RNA_def_property_ui_text(prop, "Select", "Node selection state");
10029
10030 prop = RNA_def_property(srna, "show_options", PROP_BOOLEAN, PROP_NONE);
10031 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_OPTIONS);
10033 prop,
10034 "Show Options",
10035 "Whether the node options are visible, e.g. the selected data-block of a node group node");
10036 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
10037
10038 prop = RNA_def_property(srna, "show_preview", PROP_BOOLEAN, PROP_NONE);
10039 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_PREVIEW);
10040 RNA_def_property_ui_text(prop, "Show Preview", "");
10041 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
10042
10043 prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
10044 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_COLLAPSED);
10045 RNA_def_property_ui_text(prop, "Collapse", "Node collapsed state");
10046 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
10047
10048 prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
10049 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_MUTED);
10050 RNA_def_property_boolean_funcs(prop, nullptr, "rna_Node_mute_set");
10052 RNA_def_property_ui_text(prop, "Mute", "");
10053 RNA_def_property_update(prop, 0, "rna_Node_update");
10054
10055 prop = RNA_def_property(srna, "show_texture", PROP_BOOLEAN, PROP_NONE);
10056 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_ACTIVE_TEXTURE);
10057 RNA_def_property_ui_text(prop, "Show Texture", "Display node in viewport textured shading mode");
10058 RNA_def_property_update(prop, 0, "rna_Node_update");
10059
10060 /* generic property update function */
10061 func = RNA_def_function(srna, "socket_value_update", "rna_Node_socket_value_update");
10062 RNA_def_function_ui_description(func, "Update after property changes");
10064 parm = RNA_def_pointer(func, "context", "Context", "", "");
10066
10067 func = RNA_def_function(srna, "is_registered_node_type", "rna_Node_is_registered_node_type");
10068 RNA_def_function_ui_description(func, "True if a registered node type");
10070 parm = RNA_def_boolean(func, "result", false, "Result", "");
10071 RNA_def_function_return(func, parm);
10072
10073 /* registration */
10074 prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
10076 prop, "rna_Node_bl_idname_get", "rna_Node_bl_idname_length", "rna_Node_bl_idname_set");
10078 RNA_def_property_ui_text(prop, "ID Name", "");
10079
10080 prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
10082 prop, "rna_Node_bl_label_get", "rna_Node_bl_label_length", "rna_Node_bl_label_set");
10084 RNA_def_property_ui_text(prop, "Label", "The node label");
10085
10086 prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_TRANSLATION);
10088 "rna_Node_bl_description_get",
10089 "rna_Node_bl_description_length",
10090 "rna_Node_bl_description_set");
10092
10093 prop = RNA_def_property(srna, "bl_icon", PROP_ENUM, PROP_NONE);
10094 RNA_def_property_enum_sdna(prop, nullptr, "typeinfo->ui_icon");
10096 RNA_def_property_enum_default(prop, ICON_NODE);
10098 RNA_def_property_ui_text(prop, "Icon", "The node icon");
10099
10100 prop = RNA_def_property(srna, "bl_static_type", PROP_STRING, PROP_NONE);
10101 RNA_def_property_string_funcs(prop, "rna_node_type_get", "rna_node_type_length", nullptr);
10104 prop,
10105 "Static Type",
10106 "Legacy unique node type identifier, redundant with bl_idname property");
10107
10108 /* type-based size properties */
10109 prop = RNA_def_property(srna, "bl_width_default", PROP_FLOAT, PROP_UNSIGNED);
10110 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->default_width");
10112 RNA_def_property_ui_text(prop, "Default Width", "Default width of the node when it is created");
10113
10114 prop = RNA_def_property(srna, "bl_width_min", PROP_FLOAT, PROP_UNSIGNED);
10115 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->minwidth");
10118 prop, "Minimum Width", "When changing the node's size, it has at least this width");
10119
10120 prop = RNA_def_property(srna, "bl_width_max", PROP_FLOAT, PROP_UNSIGNED);
10121 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->maxwidth");
10124 prop, "Maximum Width", "When changing the node's size, it can have at most this width");
10125
10126 prop = RNA_def_property(srna, "bl_height_default", PROP_FLOAT, PROP_UNSIGNED);
10127 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->height");
10130 prop,
10131 "Default Height",
10132 "Default height of the node when it is created (mostly unused, see Height)");
10133
10134 prop = RNA_def_property(srna, "bl_height_min", PROP_FLOAT, PROP_UNSIGNED);
10135 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->minheight");
10138 prop,
10139 "Minimum Height",
10140 "When changing the node's size, it has at least this height (mostly unused, see Height)");
10141
10142 prop = RNA_def_property(srna, "bl_height_max", PROP_FLOAT, PROP_UNSIGNED);
10143 RNA_def_property_float_sdna(prop, nullptr, "typeinfo->maxheight");
10146 "Maximum Height",
10147 "When changing the node's size, it can have at most this height "
10148 "(mostly unused, see Height)");
10149
10150 /* poll */
10151 func = RNA_def_function(srna, "poll", nullptr);
10153 func, "If non-null output is returned, the node type can be added to the tree");
10155 RNA_def_function_return(func, RNA_def_boolean(func, "visible", false, "", ""));
10156 parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", "");
10158
10159 func = RNA_def_function(srna, "poll_instance", nullptr);
10161 func, "If non-null output is returned, the node can be added to the tree");
10163 RNA_def_function_return(func, RNA_def_boolean(func, "visible", false, "", ""));
10164 parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", "");
10166
10167 /* update */
10168 func = RNA_def_function(srna, "update", nullptr);
10170 func, "Update on node graph topology changes (adding or removing nodes and links)");
10172
10173 /* insert_link */
10174 func = RNA_def_function(srna, "insert_link", nullptr);
10175 RNA_def_function_ui_description(func, "Handle creation of a link to or from the node");
10177 parm = RNA_def_pointer(func, "link", "NodeLink", "Link", "Node link that will be inserted");
10179
10180 /* init */
10181 func = RNA_def_function(srna, "init", nullptr);
10182 RNA_def_function_ui_description(func, "Initialize a new instance of this node");
10184 parm = RNA_def_pointer(func, "context", "Context", "", "");
10186
10187 /* copy */
10188 func = RNA_def_function(srna, "copy", nullptr);
10190 "Initialize a new instance of this node from an existing node");
10192 parm = RNA_def_pointer(func, "node", "Node", "Node", "Existing node to copy");
10194
10195 /* free */
10196 func = RNA_def_function(srna, "free", nullptr);
10197 RNA_def_function_ui_description(func, "Clean up node on removal");
10199
10200 /* draw buttons */
10201 func = RNA_def_function(srna, "draw_buttons", nullptr);
10202 RNA_def_function_ui_description(func, "Draw node buttons");
10204 parm = RNA_def_pointer(func, "context", "Context", "", "");
10206 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
10207 RNA_def_property_struct_type(parm, "UILayout");
10208 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
10210
10211 /* draw buttons extended */
10212 func = RNA_def_function(srna, "draw_buttons_ext", nullptr);
10213 RNA_def_function_ui_description(func, "Draw node buttons in the sidebar");
10215 parm = RNA_def_pointer(func, "context", "Context", "", "");
10217 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
10218 RNA_def_property_struct_type(parm, "UILayout");
10219 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
10221
10222 /* dynamic label */
10223 func = RNA_def_function(srna, "draw_label", nullptr);
10224 RNA_def_function_ui_description(func, "Returns a dynamic label string");
10226 parm = RNA_def_string(func, "label", nullptr, MAX_NAME, "Label", "");
10228 parm, PROP_THICK_WRAP, ParameterFlag(0)); /* needed for string return value */
10229 RNA_def_function_output(func, parm);
10230
10231 func = RNA_def_function(srna,
10232 "debug_zone_body_lazy_function_graph",
10233 "rna_NodeTree_debug_zone_body_lazy_function_graph");
10235 func, "Get the internal lazy-function graph for the body of this zone");
10237 parm = RNA_def_string(func, "dot_graph", nullptr, INT32_MAX, "Dot Graph", "Graph in dot format");
10240 RNA_def_function_output(func, parm);
10241
10242 func = RNA_def_function(
10243 srna, "debug_zone_lazy_function_graph", "rna_NodeTree_debug_zone_lazy_function_graph");
10244 RNA_def_function_ui_description(func, "Get the internal lazy-function graph for this zone");
10246 parm = RNA_def_string(func, "dot_graph", nullptr, INT32_MAX, "Dot Graph", "Graph in dot format");
10249 RNA_def_function_output(func, parm);
10250}
10251
10253{
10254 StructRNA *srna;
10255 PropertyRNA *prop;
10256
10257 srna = RNA_def_struct(brna, "NodeInternalLink", nullptr);
10259 "Node Internal Link",
10260 "Internal link used by muted nodes to connect input to output sockets");
10261
10262 prop = RNA_def_property(srna, "from_socket", PROP_POINTER, PROP_NONE);
10263 RNA_def_property_struct_type(prop, "NodeSocket");
10268 prop, "rna_NodeInternalLink_from_socket_get", nullptr, nullptr, nullptr);
10269 RNA_def_property_ui_text(prop, "From Socket", "");
10270
10271 prop = RNA_def_property(srna, "to_socket", PROP_POINTER, PROP_NONE);
10272 RNA_def_property_struct_type(prop, "NodeSocket");
10277 prop, "rna_NodeInternalLink_to_socket_get", nullptr, nullptr, nullptr);
10278 RNA_def_property_ui_text(prop, "To Socket", "");
10279}
10280
10282{
10283 StructRNA *srna;
10284 PropertyRNA *prop;
10285 FunctionRNA *func;
10286 PropertyRNA *parm;
10287
10288 srna = RNA_def_struct(brna, "NodeLink", nullptr);
10289 RNA_def_struct_ui_text(srna, "NodeLink", "Link between nodes in a node tree");
10290 RNA_def_struct_sdna(srna, "bNodeLink");
10291 RNA_def_struct_ui_icon(srna, ICON_NODE);
10292
10293 prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
10294 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_LINK_VALID);
10295 RNA_def_property_ui_text(prop, "Valid", "Link is valid");
10296 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
10297
10298 prop = RNA_def_property(srna, "is_muted", PROP_BOOLEAN, PROP_NONE);
10299 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NODE_LINK_MUTED);
10300 RNA_def_property_ui_text(prop, "Muted", "Link is muted and can be ignored");
10301 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
10302
10303 prop = RNA_def_property(srna, "from_node", PROP_POINTER, PROP_NONE);
10304 RNA_def_property_pointer_sdna(prop, nullptr, "fromnode");
10305 RNA_def_property_struct_type(prop, "Node");
10309 RNA_def_property_ui_text(prop, "From node", "");
10310
10311 prop = RNA_def_property(srna, "to_node", PROP_POINTER, PROP_NONE);
10312 RNA_def_property_pointer_sdna(prop, nullptr, "tonode");
10313 RNA_def_property_struct_type(prop, "Node");
10317 RNA_def_property_ui_text(prop, "To node", "");
10318
10319 prop = RNA_def_property(srna, "from_socket", PROP_POINTER, PROP_NONE);
10320 RNA_def_property_pointer_sdna(prop, nullptr, "fromsock");
10321 RNA_def_property_struct_type(prop, "NodeSocket");
10325 RNA_def_property_ui_text(prop, "From socket", "");
10326
10327 prop = RNA_def_property(srna, "to_socket", PROP_POINTER, PROP_NONE);
10328 RNA_def_property_pointer_sdna(prop, nullptr, "tosock");
10329 RNA_def_property_struct_type(prop, "NodeSocket");
10333 RNA_def_property_ui_text(prop, "To socket", "");
10334
10335 prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE);
10336 RNA_def_property_boolean_funcs(prop, "rna_NodeLink_is_hidden_get", nullptr);
10340 RNA_def_property_ui_text(prop, "Is Hidden", "Link is hidden due to invisible sockets");
10341
10342 prop = RNA_def_property(srna, "multi_input_sort_id", PROP_INT, PROP_UNSIGNED);
10345 prop,
10346 "Multi Input Sort ID",
10347 "Used to sort multiple links coming into the same input. The highest ID is at the top.");
10348
10349 func = RNA_def_function(
10350 srna, "swap_multi_input_sort_id", "rna_NodeLink_swap_multi_input_sort_id");
10352 func, "Swap the order of two links connected to the same multi-input socket");
10354 parm = RNA_def_pointer(func,
10355 "other",
10356 "NodeLink",
10357 "Other",
10358 "The other link. Must link to the same multi-input socket.");
10360}
10361
10363{
10364 StructRNA *srna;
10365 PropertyRNA *parm, *prop;
10366 FunctionRNA *func;
10367
10368 RNA_def_property_srna(cprop, "Nodes");
10369 srna = RNA_def_struct(brna, "Nodes", nullptr);
10370 RNA_def_struct_sdna(srna, "bNodeTree");
10371 RNA_def_struct_ui_text(srna, "Nodes", "Collection of Nodes");
10372
10373 func = RNA_def_function(srna, "new", "rna_NodeTree_node_new");
10374 RNA_def_function_ui_description(func, "Add a node to this node tree");
10376 /* XXX warning note should eventually be removed,
10377 * added this here to avoid frequent confusion with API changes from "type" to "bl_idname"
10378 */
10379 parm = RNA_def_string(
10380 func,
10381 "type",
10382 nullptr,
10383 MAX_NAME,
10384 "Type",
10385 "Type of node to add (Warning: should be same as node.bl_idname, not node.type!)");
10387 /* return value */
10388 parm = RNA_def_pointer(func, "node", "Node", "", "New node");
10390 RNA_def_function_return(func, parm);
10391
10392 func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove");
10393 RNA_def_function_ui_description(func, "Remove a node from this node tree");
10395 parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove");
10398
10399 func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear");
10400 RNA_def_function_ui_description(func, "Remove all nodes from this node tree");
10402
10403 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
10404 RNA_def_property_struct_type(prop, "Node");
10406 prop, "rna_NodeTree_active_node_get", "rna_NodeTree_active_node_set", nullptr, nullptr);
10408 RNA_def_property_ui_text(prop, "Active Node", "Active node in this tree");
10409 RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, "rna_NodeTree_update");
10410}
10411
10413{
10414 StructRNA *srna;
10415 PropertyRNA *parm;
10416 FunctionRNA *func;
10417
10418 RNA_def_property_srna(cprop, "NodeLinks");
10419 srna = RNA_def_struct(brna, "NodeLinks", nullptr);
10420 RNA_def_struct_sdna(srna, "bNodeTree");
10421 RNA_def_struct_ui_text(srna, "Node Links", "Collection of Node Links");
10422
10423 func = RNA_def_function(srna, "new", "rna_NodeTree_link_new");
10424 RNA_def_function_ui_description(func, "Add a node link to this node tree");
10426 parm = RNA_def_pointer(func, "input", "NodeSocket", "", "The input socket");
10428 parm = RNA_def_pointer(func, "output", "NodeSocket", "", "The output socket");
10430 RNA_def_boolean(func,
10431 "verify_limits",
10432 true,
10433 "Verify Limits",
10434 "Remove existing links if connection limit is exceeded");
10435 RNA_def_boolean(func,
10436 "handle_dynamic_sockets",
10437 false,
10438 "Handle Dynamic Sockets",
10439 "Handle node specific features like virtual sockets");
10440 /* return */
10441 parm = RNA_def_pointer(func, "link", "NodeLink", "", "New node link");
10442 RNA_def_function_return(func, parm);
10443
10444 func = RNA_def_function(srna, "remove", "rna_NodeTree_link_remove");
10445 RNA_def_function_ui_description(func, "remove a node link from the node tree");
10447 parm = RNA_def_pointer(func, "link", "NodeLink", "", "The node link to remove");
10450
10451 func = RNA_def_function(srna, "clear", "rna_NodeTree_link_clear");
10452 RNA_def_function_ui_description(func, "remove all node links from the node tree");
10454}
10455
10457{
10458 StructRNA *srna;
10459 PropertyRNA *prop;
10460 FunctionRNA *func;
10461 PropertyRNA *parm;
10462
10463 static const EnumPropertyItem static_type_items[] = {
10465 "UNDEFINED",
10466 ICON_QUESTION,
10467 "Undefined",
10468 "Undefined type of nodes (can happen e.g. when a linked node tree goes missing)"},
10469 {NTREE_CUSTOM, "CUSTOM", ICON_NONE, "Custom", "Custom nodes"},
10470 {NTREE_SHADER, "SHADER", ICON_MATERIAL, "Shader", "Shader nodes"},
10471 {NTREE_TEXTURE, "TEXTURE", ICON_TEXTURE, "Texture", "Texture nodes"},
10472 {NTREE_COMPOSIT, "COMPOSITING", ICON_RENDERLAYERS, "Compositing", "Compositing nodes"},
10473 {NTREE_GEOMETRY, "GEOMETRY", ICON_GEOMETRY_NODES, "Geometry", "Geometry nodes"},
10474 {0, nullptr, 0, nullptr, nullptr},
10475 };
10476
10477 srna = RNA_def_struct(brna, "NodeTree", "ID");
10479 srna,
10480 "Node Tree",
10481 "Node tree consisting of linked nodes used for shading, textures and compositing");
10482 RNA_def_struct_sdna(srna, "bNodeTree");
10483 RNA_def_struct_ui_icon(srna, ICON_NODETREE);
10484 RNA_def_struct_refine_func(srna, "rna_NodeTree_refine");
10485 RNA_def_struct_register_funcs(srna, "rna_NodeTree_register", "rna_NodeTree_unregister", nullptr);
10486
10487 prop = RNA_def_property(srna, "color_tag", PROP_ENUM, PROP_NONE);
10489 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "rna_NodeTree_color_tag_itemf");
10491 prop, "Color Tag", "Color tag of the node group which influences the header color");
10492 RNA_def_property_update(prop, NC_NODE, nullptr);
10493
10494 prop = RNA_def_property(srna, "default_group_node_width", PROP_INT, PROP_NONE);
10498 prop, "Default Group Node Width", "The width for newly created group nodes");
10499 RNA_def_property_update(prop, NC_NODE, nullptr);
10500
10501 prop = RNA_def_property(srna, "view_center", PROP_FLOAT, PROP_XYZ);
10502 RNA_def_property_array(prop, 2);
10503 RNA_def_property_float_sdna(prop, nullptr, "view_center");
10505 prop, "View Center", "The current location (offset) of the view for this Node Tree");
10507
10508 prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
10509 RNA_def_property_ui_text(prop, "Description", "Description of the node tree");
10510 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10511
10512 /* AnimData */
10514
10515 /* Nodes Collection */
10516 prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE);
10517 RNA_def_property_collection_sdna(prop, nullptr, "nodes", nullptr);
10518 RNA_def_property_struct_type(prop, "Node");
10520 RNA_def_property_ui_text(prop, "Nodes", "");
10521 rna_def_nodetree_nodes_api(brna, prop);
10522
10523 /* NodeLinks Collection */
10524 prop = RNA_def_property(srna, "links", PROP_COLLECTION, PROP_NONE);
10525 RNA_def_property_collection_sdna(prop, nullptr, "links", nullptr);
10526 RNA_def_property_struct_type(prop, "NodeLink");
10527 RNA_def_property_ui_text(prop, "Links", "");
10528 rna_def_nodetree_link_api(brna, prop);
10529
10530 /* Annotation */
10531 prop = RNA_def_property(srna, "annotation", PROP_POINTER, PROP_NONE);
10532 RNA_def_property_pointer_sdna(prop, nullptr, "gpd");
10533 RNA_def_property_struct_type(prop, "Annotation");
10535 prop, nullptr, nullptr, nullptr, "rna_GPencil_datablocks_annotations_poll");
10538 RNA_def_property_ui_text(prop, "Annotation", "Annotation data");
10539 RNA_def_property_update(prop, NC_NODE, nullptr);
10540
10541 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
10543 RNA_def_property_enum_items(prop, static_type_items);
10545 prop,
10546 "Type",
10547 "Node Tree type (deprecated, bl_idname is the actual node tree type identifier)");
10548
10549 prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
10550 RNA_def_property_pointer_sdna(prop, nullptr, "tree_interface");
10551 RNA_def_property_struct_type(prop, "NodeTreeInterface");
10553 RNA_def_property_ui_text(prop, "Interface", "Interface declaration for this node tree");
10554 /* exposed as a function for runtime interface type properties */
10555 func = RNA_def_function(srna, "interface_update", "rna_NodeTree_interface_update");
10556 RNA_def_function_ui_description(func, "Updated node group interface");
10557 parm = RNA_def_pointer(func, "context", "Context", "", "");
10559
10560 func = RNA_def_function(srna, "contains_tree", "rna_NodeTree_contains_tree");
10562 func,
10563 "Check if the node tree contains another. Used to avoid creating recursive node groups.");
10564 parm = RNA_def_pointer(
10565 func, "sub_tree", "NodeTree", "Node Tree", "Node tree for recursive check");
10567 parm = RNA_def_property(func, "contained", PROP_BOOLEAN, PROP_NONE);
10568 RNA_def_function_return(func, parm);
10569
10570 /* registration */
10571 prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
10573 "rna_NodeTree_bl_idname_get",
10574 "rna_NodeTree_bl_idname_length",
10575 "rna_NodeTree_bl_idname_set");
10577 RNA_def_property_ui_text(prop, "ID Name", "");
10578
10579 prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
10581 "rna_NodeTree_bl_label_get",
10582 "rna_NodeTree_bl_label_length",
10583 "rna_NodeTree_bl_label_set");
10585 RNA_def_property_ui_text(prop, "Label", "The node tree label");
10586
10587 prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_TRANSLATION);
10589 "rna_NodeTree_bl_description_get",
10590 "rna_NodeTree_bl_description_length",
10591 "rna_NodeTree_bl_description_set");
10593
10594 prop = RNA_def_property(srna, "bl_icon", PROP_ENUM, PROP_NONE);
10595 RNA_def_property_enum_sdna(prop, nullptr, "typeinfo->ui_icon");
10597 RNA_def_property_enum_default(prop, ICON_NODETREE);
10599 RNA_def_property_ui_text(prop, "Icon", "The node tree icon");
10600
10601 prop = RNA_def_property(srna, "bl_use_group_interface", PROP_BOOLEAN, PROP_NONE);
10602 RNA_def_property_boolean_negative_sdna(prop, nullptr, "typeinfo->no_group_interface", 1);
10606 "Use Group Interface",
10607 "Determines the visibility of some UI elements related to node groups");
10608
10609 /* poll */
10610 func = RNA_def_function(srna, "poll", nullptr);
10611 RNA_def_function_ui_description(func, "Check visibility in the editor");
10613 parm = RNA_def_pointer(func, "context", "Context", "", "");
10615 RNA_def_function_return(func, RNA_def_boolean(func, "visible", false, "", ""));
10616
10617 /* update */
10618 func = RNA_def_function(srna, "update", nullptr);
10619 RNA_def_function_ui_description(func, "Update on editor changes");
10621
10622 /* get a node tree from context */
10623 func = RNA_def_function(srna, "get_from_context", nullptr);
10624 RNA_def_function_ui_description(func, "Get a node tree from the context");
10626 parm = RNA_def_pointer(func, "context", "Context", "", "");
10628 parm = RNA_def_pointer(
10629 func, "result_1", "NodeTree", "Node Tree", "Active node tree from context");
10630 RNA_def_function_output(func, parm);
10631 parm = RNA_def_pointer(
10632 func, "result_2", "ID", "Owner ID", "ID data-block that owns the node tree");
10633 RNA_def_function_output(func, parm);
10634 parm = RNA_def_pointer(
10635 func, "result_3", "ID", "From ID", "Original ID data-block selected from the context");
10636 RNA_def_function_output(func, parm);
10637
10638 /* Check for support of a socket type with a type identifier. */
10639 func = RNA_def_function(srna, "valid_socket_type", nullptr);
10640 RNA_def_function_ui_description(func, "Check if the socket type is valid for the node tree");
10642 parm = RNA_def_string(
10643 func, "idname", "NodeSocket", MAX_NAME, "Socket Type", "Identifier of the socket type");
10645 RNA_def_function_return(func, RNA_def_boolean(func, "valid", false, "", ""));
10646
10647 func = RNA_def_function(
10648 srna, "debug_lazy_function_graph", "rna_NodeTree_debug_lazy_function_graph");
10649 RNA_def_function_ui_description(func, "Get the internal lazy-function graph for this node tree");
10651 parm = RNA_def_string(func, "dot_graph", nullptr, INT32_MAX, "Dot Graph", "Graph in dot format");
10654 RNA_def_function_output(func, parm);
10655}
10656
10658{
10659 StructRNA *srna;
10660 PropertyRNA *prop;
10661
10662 srna = RNA_def_struct(brna, "CompositorNodeTree", "NodeTree");
10664 srna, "Compositor Node Tree", "Node tree consisting of linked nodes used for compositing");
10665 RNA_def_struct_sdna(srna, "bNodeTree");
10666 RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
10667
10668 prop = RNA_def_property(srna, "use_viewer_border", PROP_BOOLEAN, PROP_NONE);
10669 RNA_def_property_boolean_sdna(prop, nullptr, "flag", NTREE_VIEWER_BORDER);
10671 "Viewer Region",
10672 "Unused but kept for compatibility reasons. Use boundaries for viewer "
10673 "nodes and composite backdrop");
10674 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update");
10675
10676 prop = RNA_def_property(srna, "is_strip_modifier", PROP_BOOLEAN, PROP_NONE);
10679 prop, "Strip Modifier", "The node group is used as a sequencer strip modifier");
10681 "rna_CompositorNodeTree_is_strip_modifier_get",
10682 "rna_CompositorNodeTree_is_strip_modifier_set");
10683 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10684
10685 prop = RNA_def_property(srna, "allow_usage_in_scene_compositor_effect", PROP_BOOLEAN, PROP_NONE);
10688 prop, "Scene Effect", "The node group can be used as a scene compositor effect");
10690 prop,
10691 "rna_CompositorNodeTree_allow_usage_in_scene_compositor_effect_get",
10692 "rna_CompositorNodeTree_allow_usage_in_scene_compositor_effect_set");
10693 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10694}
10695
10697{
10698 StructRNA *srna;
10699 FunctionRNA *func;
10700 PropertyRNA *parm;
10701
10702 srna = RNA_def_struct(brna, "ShaderNodeTree", "NodeTree");
10704 srna,
10705 "Shader Node Tree",
10706 "Node tree consisting of linked nodes used for materials (and other shading data-blocks)");
10707 RNA_def_struct_sdna(srna, "bNodeTree");
10708 RNA_def_struct_ui_icon(srna, ICON_MATERIAL);
10709
10710 func = RNA_def_function(srna, "get_output_node", "ntreeShaderOutputNode");
10712 "Return active shader output node for the specified target");
10713 parm = RNA_def_enum(
10714 func, "target", prop_shader_output_target_items, SHD_OUTPUT_ALL, "Target", "");
10716 parm = RNA_def_pointer(func, "node", "ShaderNode", "Node", "");
10717 RNA_def_function_return(func, parm);
10718}
10719
10721{
10722 StructRNA *srna;
10723
10724 srna = RNA_def_struct(brna, "TextureNodeTree", "NodeTree");
10726 srna, "Texture Node Tree", "Node tree consisting of linked nodes used for textures");
10727 RNA_def_struct_sdna(srna, "bNodeTree");
10728 RNA_def_struct_ui_icon(srna, ICON_TEXTURE);
10729}
10730
10732{
10733 StructRNA *srna;
10734 PropertyRNA *prop;
10735
10736 srna = RNA_def_struct(brna, "GeometryNodeTree", "NodeTree");
10738 srna, "Geometry Node Tree", "Node tree consisting of linked nodes used for geometries");
10739 RNA_def_struct_sdna(srna, "bNodeTree");
10740 RNA_def_struct_ui_icon(srna, ICON_NODETREE);
10741
10742 prop = RNA_def_property(srna, "is_tool", PROP_BOOLEAN, PROP_NONE);
10744 RNA_def_property_ui_text(prop, "Tool", "The node group is used as a tool");
10746 prop, "rna_GeometryNodeTree_is_tool_get", "rna_GeometryNodeTree_is_tool_set");
10747 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10748
10749 prop = RNA_def_property(srna, "node_tool_idname", PROP_STRING, PROP_NONE);
10752 prop, "Node Tool Identifier", "Unique operator identifier for the node tool");
10754 "rna_GeometryNodeTree_node_tool_idname_get",
10755 "rna_GeometryNodeTree_node_tool_idname_length",
10756 "rna_GeometryNodeTree_node_tool_idname_set");
10757 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10758
10759 prop = RNA_def_property(srna, "is_modifier", PROP_BOOLEAN, PROP_NONE);
10761 RNA_def_property_ui_text(prop, "Modifier", "The node group is used as a geometry modifier");
10763 prop, "rna_GeometryNodeTree_is_modifier_get", "rna_GeometryNodeTree_is_modifier_set");
10764 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10765
10766 prop = RNA_def_property(srna, "is_mode_object", PROP_BOOLEAN, PROP_NONE);
10768 RNA_def_property_ui_text(prop, "Edit", "The node group is used in object mode");
10770 prop, "rna_GeometryNodeTree_is_mode_object_get", "rna_GeometryNodeTree_is_mode_object_set");
10771 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10772
10773 prop = RNA_def_property(srna, "is_mode_edit", PROP_BOOLEAN, PROP_NONE);
10775 RNA_def_property_ui_text(prop, "Edit", "The node group is used in edit mode");
10777 prop, "rna_GeometryNodeTree_is_mode_edit_get", "rna_GeometryNodeTree_is_mode_edit_set");
10778 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10779
10780 prop = RNA_def_property(srna, "is_mode_sculpt", PROP_BOOLEAN, PROP_NONE);
10782 RNA_def_property_ui_text(prop, "Sculpt", "The node group is used in sculpt mode");
10784 prop, "rna_GeometryNodeTree_is_mode_sculpt_get", "rna_GeometryNodeTree_is_mode_sculpt_set");
10785 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10786
10787 prop = RNA_def_property(srna, "is_mode_paint", PROP_BOOLEAN, PROP_NONE);
10789 RNA_def_property_ui_text(prop, "Paint", "The node group is used in paint mode");
10791 prop, "rna_GeometryNodeTree_is_mode_paint_get", "rna_GeometryNodeTree_is_mode_paint_set");
10792 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10793
10794 prop = RNA_def_property(srna, "is_type_mesh", PROP_BOOLEAN, PROP_NONE);
10796 RNA_def_property_ui_text(prop, "Mesh", "The node group is used for meshes");
10798 prop, "rna_GeometryNodeTree_is_type_mesh_get", "rna_GeometryNodeTree_is_type_mesh_set");
10799 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10800
10801 prop = RNA_def_property(srna, "is_type_curve", PROP_BOOLEAN, PROP_NONE);
10803 RNA_def_property_ui_text(prop, "Curves", "The node group is used for curves");
10805 prop, "rna_GeometryNodeTree_is_type_curve_get", "rna_GeometryNodeTree_is_type_curve_set");
10806 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10807
10808 prop = RNA_def_property(srna, "is_type_pointcloud", PROP_BOOLEAN, PROP_NONE);
10810 RNA_def_property_ui_text(prop, "Point Cloud", "The node group is used for point clouds");
10812 "rna_GeometryNodeTree_is_type_pointcloud_get",
10813 "rna_GeometryNodeTree_is_type_pointcloud_set");
10814 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10815
10816 prop = RNA_def_property(srna, "use_wait_for_click", PROP_BOOLEAN, PROP_NONE);
10819 "Wait for Click",
10820 "Wait for mouse click input before running the operator from a menu");
10822 "rna_GeometryNodeTree_use_wait_for_click_get",
10823 "rna_GeometryNodeTree_use_wait_for_click_set");
10824 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10825
10826 prop = RNA_def_property(srna, "is_type_grease_pencil", PROP_BOOLEAN, PROP_NONE);
10828 RNA_def_property_ui_text(prop, "Grease Pencil", "The node group is used for Grease Pencil");
10830 "rna_GeometryNodeTree_is_type_grease_pencil_get",
10831 "rna_GeometryNodeTree_is_type_grease_pencil_set");
10832 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update_asset");
10833
10834 prop = RNA_def_property(srna, "show_modifier_manage_panel", PROP_BOOLEAN, PROP_NONE);
10836 "rna_GeometryNodeTree_modifier_manage_panel_get",
10837 "rna_GeometryNodeTree_modifier_manage_panel_set");
10838 RNA_def_property_boolean_negative_sdna(prop, nullptr, "flag", 0);
10841 prop,
10842 "Show Manage Panel",
10843 "Turn on the option to display the manage panel when creating a modifier");
10844 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeTree_update");
10845}
10846
10848 const char *struct_name,
10849 const char *base_name)
10850{
10851 StructRNA *srna;
10852 FunctionRNA *func;
10853 PropertyRNA *parm;
10854
10855 srna = RNA_def_struct(brna, struct_name, base_name);
10856 RNA_def_struct_sdna(srna, "bNode");
10857
10858 func = RNA_def_function(srna, "is_registered_node_type", "rna_Node_is_registered_node_type");
10859 RNA_def_function_ui_description(func, "True if a registered node type");
10861 parm = RNA_def_boolean(func, "result", false, "Result", "");
10862 RNA_def_function_return(func, parm);
10863
10864 /* Exposes the socket template type lists in RNA for use in scripts
10865 * Only used in the C nodes and not exposed in the base class to
10866 * keep the namespace clean for py-nodes. */
10867 func = RNA_def_function(srna, "input_template", "rna_NodeInternal_input_template");
10868 RNA_def_function_ui_description(func, "Input socket template");
10870 parm = RNA_def_property(func, "index", PROP_INT, PROP_UNSIGNED);
10871 RNA_def_property_ui_text(parm, "Index", "");
10873 parm = RNA_def_property(func, "result", PROP_POINTER, PROP_NONE);
10874 RNA_def_property_struct_type(parm, "NodeInternalSocketTemplate");
10876 RNA_def_function_return(func, parm);
10877
10878 func = RNA_def_function(srna, "output_template", "rna_NodeInternal_output_template");
10879 RNA_def_function_ui_description(func, "Output socket template");
10881 parm = RNA_def_property(func, "index", PROP_INT, PROP_UNSIGNED);
10882 RNA_def_property_ui_text(parm, "Index", "");
10884 parm = RNA_def_property(func, "result", PROP_POINTER, PROP_NONE);
10885 RNA_def_property_struct_type(parm, "NodeInternalSocketTemplate");
10887 RNA_def_function_return(func, parm);
10888
10889 return srna;
10890}
10891
10892static void rna_def_nodes(BlenderRNA *brna)
10893{
10894 const auto define = [&](const char *base_name,
10895 const char *struct_name,
10896 void (*func)(BlenderRNA *, StructRNA *) = nullptr) {
10897 StructRNA *srna = define_specific_node(brna, struct_name, base_name);
10898 if (func) {
10899 func(brna, srna);
10900 }
10901 };
10902
10903 /* Disabling clang-format because:
10904 * - It's more readable when the lines are aligned.
10905 * - It's easier to sort the lines alphabetically with automated tools. Keeping the lines sorted
10906 * avoids merge conflicts in many cases when multiple people add nodes at the same time.
10907 */
10908 /* clang-format off */
10909
10910 define("NodeInternal", "NodeFrame", def_frame);
10911 define("NodeInternal", "NodeGroup", def_group);
10912 define("NodeInternal", "NodeGroupInput", def_group_input);
10913 define("NodeInternal", "NodeGroupOutput", def_group_output);
10914 define("NodeInternal", "NodeReroute", def_reroute);
10915 define("NodeInternal", "NodeImplicitConversion", def_implicit_conversion);
10916 define ("NodeInternal", "NodeComment", def_comment);
10917
10918 define("NodeInternal", "NodeClosureInput", def_closure_input);
10919 define("NodeInternal", "NodeClosureOutput", def_closure_output);
10920 define("NodeInternal", "NodeCombineBundle", def_combine_bundle);
10921 define("NodeInternal", "NodeEnableOutput");
10922 define("NodeInternal", "NodeEvaluateClosure", def_evaluate_closure);
10923 define("NodeInternal", "NodeGetBundleItem");
10924 define("NodeInternal", "NodeGetNestedBundlePaths");
10925 define("NodeInternal", "NodeJoinBundle");
10926 define("NodeInternal", "NodeSeparateBundle", def_separate_bundle);
10927 define("NodeInternal", "NodeStoreBundleItem");
10928
10929 define("ShaderNode", "ShaderNodeAddShader");
10930 define("ShaderNode", "ShaderNodeAmbientOcclusion", def_sh_ambient_occlusion);
10931 define("ShaderNode", "ShaderNodeAttribute", def_sh_attribute);
10932 define("ShaderNode", "ShaderNodeBackground");
10933 define("ShaderNode", "ShaderNodeBevel", def_sh_bevel);
10934 define("ShaderNode", "ShaderNodeBlackbody");
10935 define("ShaderNode", "ShaderNodeBrightContrast");
10936 define("ShaderNode", "ShaderNodeBsdfAnisotropic", def_glossy);
10937 define("ShaderNode", "ShaderNodeBsdfDiffuse");
10938 define("ShaderNode", "ShaderNodeBsdfGlass", def_glass);
10939 define("ShaderNode", "ShaderNodeBsdfHair", def_hair);
10940 define("ShaderNode", "ShaderNodeBsdfHairPrincipled", def_hair_principled);
10941 define("ShaderNode", "ShaderNodeBsdfMetallic", def_metallic);
10942 define("ShaderNode", "ShaderNodeBsdfPrincipled", def_principled);
10943 define("ShaderNode", "ShaderNodeBsdfRayPortal");
10944 define("ShaderNode", "ShaderNodeBsdfRefraction", def_refraction);
10945 define("ShaderNode", "ShaderNodeBsdfSheen", def_sheen);
10946 define("ShaderNode", "ShaderNodeBsdfToon", def_toon);
10947 define("ShaderNode", "ShaderNodeBsdfTranslucent");
10948 define("ShaderNode", "ShaderNodeBsdfTransparent");
10949 define("ShaderNode", "ShaderNodeBump", def_sh_bump);
10950 define("ShaderNode", "ShaderNodeCameraData");
10951 define("ShaderNode", "ShaderNodeClamp", def_clamp);
10952 define("ShaderNode", "ShaderNodeCombineColor", def_sh_combsep_color);
10953 define("ShaderNode", "ShaderNodeCombineXYZ");
10954 define("ShaderNode", "ShaderNodeDisplacement", def_sh_displacement);
10955 define("ShaderNode", "ShaderNodeEeveeSpecular");
10956 define("ShaderNode", "ShaderNodeEmission");
10957 define("ShaderNode", "ShaderNodeFloatCurve", def_float_curve);
10958 define("ShaderNode", "ShaderNodeFresnel");
10959 define("ShaderNode", "ShaderNodeGamma");
10960 define("ShaderNode", "ShaderNodeHairInfo");
10961 define("ShaderNode", "ShaderNodeHoldout");
10962 define("ShaderNode", "ShaderNodeHueSaturation");
10963 define("ShaderNode", "ShaderNodeInvert");
10964 define("ShaderNode", "ShaderNodeLayerWeight");
10965 define("ShaderNode", "ShaderNodeLightAccumulation");
10966 define("ShaderNode", "ShaderNodeLightEvaluation", def_light_evaluation);
10967 define("ShaderNode", "ShaderNodeLightFalloff");
10968 define("ShaderNode", "ShaderNodeLightInfo");
10969 define("ShaderNode", "ShaderNodeLightIterInternalInput");
10970 define("ShaderNode", "ShaderNodeLightIterInternalOutput");
10971 define("ShaderNode", "ShaderNodeLightPath");
10972 define("ShaderNode", "ShaderNodeMapping", def_sh_mapping);
10973 define("ShaderNode", "ShaderNodeMapRange", def_map_range);
10974 define("ShaderNode", "ShaderNodeMath", def_math);
10975 define("ShaderNode", "ShaderNodeMix", def_sh_mix);
10976 define("ShaderNode", "ShaderNodeMixRGB", def_mix_rgb);
10977 define("ShaderNode", "ShaderNodeMixShader");
10978 define("ShaderNode", "ShaderNodeNewGeometry");
10979 define("ShaderNode", "ShaderNodeNormal");
10980 define("ShaderNode", "ShaderNodeNormalMap", def_sh_normal_map);
10981 define("ShaderNode", "ShaderNodeObjectInfo");
10982 define("ShaderNode", "ShaderNodeOutputAOV", def_sh_output_aov);
10983 define("ShaderNode", "ShaderNodeOutputLight", def_sh_output);
10984 define("ShaderNode", "ShaderNodeOutputLineStyle", def_sh_output_linestyle);
10985 define("ShaderNode", "ShaderNodeOutputMaterial", def_sh_output);
10986 define("ShaderNode", "ShaderNodeOutputWorld", def_sh_output);
10987 define("ShaderNode", "ShaderNodeParticleInfo");
10988 define("ShaderNode", "ShaderNodePointInfo");
10989 define("ShaderNode", "ShaderNodeRadialTiling", def_sh_radial_tiling);
10990 define("ShaderNode", "ShaderNodeRaycast", def_sh_raycast);
10991 define("ShaderNode", "ShaderNodeRGB");
10992 define("ShaderNode", "ShaderNodeRGBCurve", def_rgb_curve);
10993 define("ShaderNode", "ShaderNodeRGBToBW");
10994 define("ShaderNode", "ShaderNodeScript", def_sh_script);
10995 define("ShaderNode", "ShaderNodeSeparateColor", def_sh_combsep_color);
10996 define("ShaderNode", "ShaderNodeSeparateXYZ");
10997 define("ShaderNode", "ShaderNodeShaderToRGB");
10998 define("ShaderNode", "ShaderNodeShadowRaycast");
10999 define("ShaderNode", "ShaderNodeSqueeze");
11000 define("ShaderNode", "ShaderNodeSubsurfaceScattering", def_sh_subsurface);
11001 define("ShaderNode", "ShaderNodeTangent", def_sh_tangent);
11002 define("ShaderNode", "ShaderNodeTexBrick", def_sh_tex_brick);
11003 define("ShaderNode", "ShaderNodeTexChecker", def_sh_tex_checker);
11004 define("ShaderNode", "ShaderNodeTexCoord", def_sh_tex_coord);
11005 define("ShaderNode", "ShaderNodeTexEnvironment", def_sh_tex_environment);
11006 define("ShaderNode", "ShaderNodeTexGabor", def_sh_tex_gabor);
11007 define("ShaderNode", "ShaderNodeTexGradient", def_sh_tex_gradient);
11008 define("ShaderNode", "ShaderNodeTexIES", def_sh_tex_ies);
11009 define("ShaderNode", "ShaderNodeTexImage", def_sh_tex_image);
11010 define("ShaderNode", "ShaderNodeTexMagic", def_sh_tex_magic);
11011 define("ShaderNode", "ShaderNodeTexNoise", def_sh_tex_noise);
11012 define("ShaderNode", "ShaderNodeTexSky", def_sh_tex_sky);
11013 define("ShaderNode", "ShaderNodeTexVoronoi", def_sh_tex_voronoi);
11014 define("ShaderNode", "ShaderNodeTexWave", def_sh_tex_wave);
11015 define("ShaderNode", "ShaderNodeTexWhiteNoise", def_sh_tex_white_noise);
11016 define("ShaderNode", "ShaderNodeUVAlongStroke", def_sh_uvalongstroke);
11017 define("ShaderNode", "ShaderNodeUVMap", def_sh_uvmap);
11018 define("ShaderNode", "ShaderNodeValToRGB", def_colorramp);
11019 define("ShaderNode", "ShaderNodeValue");
11020 define("ShaderNode", "ShaderNodeVectorCurve", def_vector_curve);
11021 define("ShaderNode", "ShaderNodeVectorDisplacement", def_sh_vector_displacement);
11022 define("ShaderNode", "ShaderNodeVectorMath", def_vector_math);
11023 define("ShaderNode", "ShaderNodeVectorRotate", def_sh_vector_rotate);
11024 define("ShaderNode", "ShaderNodeVectorTransform", def_sh_vect_transform);
11025 define("ShaderNode", "ShaderNodeVertexColor", def_sh_vertex_color);
11026 define("ShaderNode", "ShaderNodeVolumeAbsorption");
11027 define("ShaderNode", "ShaderNodeVolumeInfo");
11028 define("ShaderNode", "ShaderNodeVolumePrincipled");
11029 define("ShaderNode", "ShaderNodeVolumeScatter", def_scatter);
11030 define("ShaderNode", "ShaderNodeVolumeCoefficients", def_volume_coefficients);
11031 define("ShaderNode", "ShaderNodeWavelength");
11032 define("ShaderNode", "ShaderNodeWireframe", def_sh_tex_wireframe);
11033
11034 define("CompositorNode", "CompositorNodeAlphaOver");
11035 define("CompositorNode", "CompositorNodeAntiAliasing");
11036 define("CompositorNode", "CompositorNodeBilateralblur");
11037 define("CompositorNode", "CompositorNodeBlankImage");
11038 define("CompositorNode", "CompositorNodeBlur");
11039 define("CompositorNode", "CompositorNodeBokehBlur");
11040 define("CompositorNode", "CompositorNodeBokehImage");
11041 define("CompositorNode", "CompositorNodeBoxMask");
11042 define("CompositorNode", "CompositorNodeBrightContrast");
11043 define("CompositorNode", "CompositorNodeChannelMatte");
11044 define("CompositorNode", "CompositorNodeChromaMatte");
11045 define("CompositorNode", "CompositorNodeColorBalance", def_cmp_colorbalance);
11046 define("CompositorNode", "CompositorNodeColorCorrection");
11047 define("CompositorNode", "CompositorNodeColorMatte");
11048 define("CompositorNode", "CompositorNodeColorSpill");
11049 define("CompositorNode", "CompositorNodeConvolve");
11050 define("CompositorNode", "CompositorNodeCombineColor", def_cmp_combsep_color);
11051 define("CompositorNode", "CompositorNodeConvertColorSpace", def_cmp_convert_color_space);
11052 define("CompositorNode", "CompositorNodeConvertToDisplay", def_cmp_convert_to_display);
11053 define("CompositorNode", "CompositorNodeCornerPin");
11054 define("CompositorNode", "CompositorNodeCrop");
11055 define("CompositorNode", "CompositorNodeCryptomatte", def_cmp_cryptomatte_legacy);
11056 define("CompositorNode", "CompositorNodeCryptomatteV2", def_cmp_cryptomatte);
11057 define("CompositorNode", "CompositorNodeCurveRGB", def_rgb_curve);
11058 define("CompositorNode", "CompositorNodeDBlur");
11059 define("CompositorNode", "CompositorNodeDefocus", def_cmp_defocus);
11060 define("CompositorNode", "CompositorNodeDenoise");
11061 define("CompositorNode", "CompositorNodeDespeckle");
11062 define("CompositorNode", "CompositorNodeDiffMatte");
11063 define("CompositorNode", "CompositorNodeDilateErode");
11064 define("CompositorNode", "CompositorNodeDisplace");
11065 define("CompositorNode", "CompositorNodeDistanceMatte");
11066 define("CompositorNode", "CompositorNodeDoubleEdgeMask");
11067 define("CompositorNode", "CompositorNodeEllipseMask");
11068 define("CompositorNode", "CompositorNodeExposure");
11069 define("CompositorNode", "CompositorNodeFilter");
11070 define("CompositorNode", "CompositorNodeFlip");
11071 define("CompositorNode", "CompositorNodeGamma");
11072 define("CompositorNode", "CompositorNodeGlare");
11073 define("CompositorNode", "CompositorNodeHueCorrect", def_cmp_huecorrect);
11074 define("CompositorNode", "CompositorNodeHueSat");
11075 define("CompositorNode", "CompositorNodeIDMask");
11076 define("CompositorNode", "CompositorNodeImage", def_cmp_image);
11077 define("CompositorNode", "CompositorNodeImageCoordinates");
11078 define("CompositorNode", "CompositorNodeImageInfo");
11079 define("CompositorNode", "CompositorNodeInpaint");
11080 define("CompositorNode", "CompositorNodeInvert");
11081 define("CompositorNode", "CompositorNodeKeying");
11082 define("CompositorNode", "CompositorNodeKeyingScreen", def_cmp_keyingscreen);
11083 define("CompositorNode", "CompositorNodeKuwahara");
11084 define("CompositorNode", "CompositorNodeLensdist");
11085 define("CompositorNode", "CompositorNodeLevels");
11086 define("CompositorNode", "CompositorNodeLumaMatte");
11087 define("CompositorNode", "CompositorNodeMapUV");
11088 define("CompositorNode", "CompositorNodeMask", def_cmp_mask);
11089 define("CompositorNode", "CompositorNodeMovieClip", def_cmp_movieclip);
11090 define("CompositorNode", "CompositorNodeMovieDistortion", def_cmp_moviedistortion);
11091 define("CompositorNode", "CompositorNodeNormal");
11092 define("CompositorNode", "CompositorNodeNormalize");
11093 define("CompositorNode", "CompositorNodeOutputFile", def_cmp_file_output);
11094 define("CompositorNode", "CompositorNodePixelate");
11095 define("CompositorNode", "CompositorNodePlaneTrackDeform", def_cmp_planetrackdeform);
11096 define("CompositorNode", "CompositorNodePosterize");
11097 define("CompositorNode", "CompositorNodePremulKey");
11098 define("CompositorNode", "CompositorNodeRelativeToPixel");
11099 define("CompositorNode", "CompositorNodeRGB");
11100 define("CompositorNode", "CompositorNodeRGBToBW");
11101 define("CompositorNode", "CompositorNodeRLayers", def_cmp_render_layers);
11102 define("CompositorNode", "CompositorNodeRotate");
11103 define("CompositorNode", "CompositorNodeScale");
11104 define("CompositorNode", "CompositorNodeSceneTime");
11105 define("CompositorNode", "CompositorNodeSeparateColor", def_cmp_combsep_color);
11106 define("CompositorNode", "CompositorNodeSetAlpha");
11107 define("CompositorNode", "CompositorNodeMaskToSDF");
11108 define("CompositorNode", "CompositorNodeSplit");
11109 define("CompositorNode", "CompositorNodeStabilize", def_cmp_stabilize2d);
11110 define("CompositorNode", "CompositorNodeSequencerStripInfo");
11111 define("CompositorNode", "CompositorNodeStringToImage");
11112 define("CompositorNode", "CompositorNodeSwitch");
11113 define("CompositorNode", "CompositorNodeSwitchView");
11114 define("CompositorNode", "CompositorNodeTime", def_time);
11115 define("CompositorNode", "CompositorNodeTonemap");
11116 define("CompositorNode", "CompositorNodeTrackPos", def_cmp_trackpos);
11117 define("CompositorNode", "CompositorNodeTransform");
11118 define("CompositorNode", "CompositorNodeTranslate");
11119 define("CompositorNode", "CompositorNodeVecBlur");
11120 define("CompositorNode", "CompositorNodeViewer", def_cmp_viewer);
11121 define("CompositorNode", "CompositorNodeZcombine");
11122
11123 define("TextureNode", "TextureNodeAt");
11124 define("TextureNode", "TextureNodeBricks", def_tex_bricks);
11125 define("TextureNode", "TextureNodeChecker");
11126 define("TextureNode", "TextureNodeCombineColor", def_tex_combsep_color);
11127 define("TextureNode", "TextureNodeCompose");
11128 define("TextureNode", "TextureNodeCoordinates");
11129 define("TextureNode", "TextureNodeCurveRGB", def_rgb_curve);
11130 define("TextureNode", "TextureNodeCurveTime", def_time);
11131 define("TextureNode", "TextureNodeDecompose");
11132 define("TextureNode", "TextureNodeDistance");
11133 define("TextureNode", "TextureNodeHueSaturation");
11134 define("TextureNode", "TextureNodeImage", def_tex_image);
11135 define("TextureNode", "TextureNodeInvert");
11136 define("TextureNode", "TextureNodeMath", def_math);
11137 define("TextureNode", "TextureNodeMixRGB", def_mix_rgb);
11138 define("TextureNode", "TextureNodeOutput", def_tex_output);
11139 define("TextureNode", "TextureNodeRGBToBW");
11140 define("TextureNode", "TextureNodeRotate");
11141 define("TextureNode", "TextureNodeScale");
11142 define("TextureNode", "TextureNodeSeparateColor", def_tex_combsep_color);
11143 define("TextureNode", "TextureNodeTexBlend");
11144 define("TextureNode", "TextureNodeTexClouds");
11145 define("TextureNode", "TextureNodeTexDistNoise");
11146 define("TextureNode", "TextureNodeTexMagic");
11147 define("TextureNode", "TextureNodeTexMarble");
11148 define("TextureNode", "TextureNodeTexMusgrave");
11149 define("TextureNode", "TextureNodeTexNoise");
11150 define("TextureNode", "TextureNodeTexStucci");
11151 define("TextureNode", "TextureNodeTexture", def_texture);
11152 define("TextureNode", "TextureNodeTexVoronoi");
11153 define("TextureNode", "TextureNodeTexWood");
11154 define("TextureNode", "TextureNodeTranslate");
11155 define("TextureNode", "TextureNodeValToNor");
11156 define("TextureNode", "TextureNodeValToRGB", def_colorramp);
11157 define("TextureNode", "TextureNodeViewer");
11158
11159 define("FunctionNode", "FunctionNodeAlignEulerToVector");
11160 define("FunctionNode", "FunctionNodeAlignRotationToVector");
11161 define("FunctionNode", "FunctionNodeAxesToRotation");
11162 define("FunctionNode", "FunctionNodeAxisAngleToRotation");
11163 define("FunctionNode", "FunctionNodeBitMath");
11164 define("FunctionNode", "FunctionNodeBooleanMath");
11165 define("FunctionNode", "FunctionNodeCombineColor");
11166 define("FunctionNode", "FunctionNodeCombineMatrix");
11167 define("FunctionNode", "FunctionNodeCombineTransform");
11168 define("FunctionNode", "FunctionNodeCompare");
11169 define("FunctionNode", "FunctionNodeEulerToRotation");
11170 define("FunctionNode", "FunctionNodeFindInString");
11171 define("FunctionNode", "FunctionNodeFloatToInt", def_float_to_int);
11172 define("FunctionNode", "FunctionNodeFormatString", def_fn_format_string);
11173 define("FunctionNode", "FunctionNodeGetVectorComponent");
11174 define("FunctionNode", "FunctionNodeHashValue");
11175 define("FunctionNode", "FunctionNodeInputBool", def_fn_input_bool);
11176 define("FunctionNode", "FunctionNodeInputColor", def_fn_input_color);
11177 define("FunctionNode", "FunctionNodeInputInt", def_fn_input_int);
11178 define("FunctionNode", "FunctionNodeInputIntVector", def_fn_input_int_vector);
11179 define("FunctionNode", "FunctionNodeInputMenu", def_fn_input_menu);
11180 define("FunctionNode", "FunctionNodeInputRotation", def_fn_input_rotation);
11181 define("FunctionNode", "FunctionNodeInputSpecialCharacters");
11182 define("FunctionNode", "FunctionNodeInputString", def_fn_input_string);
11183 define("FunctionNode", "FunctionNodeInputVector", def_fn_input_vector);
11184 define("FunctionNode", "FunctionNodeIntegerMath");
11185 define("FunctionNode", "FunctionNodeInvertMatrix");
11186 define("FunctionNode", "FunctionNodeInvertRotation");
11187 define("FunctionNode", "FunctionNodeMatchString");
11188 define("FunctionNode", "FunctionNodeMatrixDeterminant");
11189 define("FunctionNode", "FunctionNodeMatrixMultiply");
11190 define("FunctionNode", "FunctionNodeMatrixSVD");
11191 define("FunctionNode", "FunctionNodeProjectPoint");
11192 define("FunctionNode", "FunctionNodeQuaternionToRotation");
11193 define("FunctionNode", "FunctionNodeRandomValue", def_fn_random_value);
11194 define("FunctionNode", "FunctionNodeReplaceString");
11195 define("FunctionNode", "FunctionNodeReverseString");
11196 define("FunctionNode", "FunctionNodeRotateEuler", def_fn_rotate_euler);
11197 define("FunctionNode", "FunctionNodeRotateRotation");
11198 define("FunctionNode", "FunctionNodeRotateVector");
11199 define("FunctionNode", "FunctionNodeRotationToAxisAngle");
11200 define("FunctionNode", "FunctionNodeRotationToEuler");
11201 define("FunctionNode", "FunctionNodeRotationToQuaternion");
11202 define("FunctionNode", "FunctionNodeSeparateColor");
11203 define("FunctionNode", "FunctionNodeSeparateMatrix");
11204 define("FunctionNode", "FunctionNodeSeparateTransform");
11205 define("FunctionNode", "FunctionNodeSetStringCase");
11206 define("FunctionNode", "FunctionNodeSliceString");
11207 define("FunctionNode", "FunctionNodeSplitString");
11208 define("FunctionNode", "FunctionNodeStringLength");
11209 define("FunctionNode", "FunctionNodeStringToValue");
11210 define("FunctionNode", "FunctionNodeTransformDirection");
11211 define("FunctionNode", "FunctionNodeTransformPoint");
11212 define("FunctionNode", "FunctionNodeTransposeMatrix");
11213 define("FunctionNode", "FunctionNodeTrimString");
11214 define("FunctionNode", "FunctionNodeValueToString");
11215
11216 define("GeometryNode", "GeometryNodeAccumulateField");
11217 define("GeometryNode", "GeometryNodeApplySimulatedData");
11218 define("GeometryNode", "GeometryNodeAttributeDomainSize");
11219 define("GeometryNode", "GeometryNodeAttributeStatistic");
11220 define("GeometryNode", "GeometryNodeBake", rna_def_geo_bake);
11221 define("GeometryNode", "GeometryNodeBlurAttribute");
11222 define("GeometryNode", "GeometryNodeBoneInfo");
11223 define("GeometryNode", "GeometryNodeBoundBox");
11224 define("GeometryNode", "GeometryNodeCameraInfo");
11225 define("GeometryNode", "GeometryNodeCaptureAttribute", rna_def_geo_capture_attribute);
11226 define("GeometryNode", "GeometryNodeClosureToList", def_geo_closure_to_list);
11227 define("GeometryNode", "GeometryNodeClusterByConnected");
11228 define("GeometryNode", "GeometryNodeClusterByDistance");
11229 define("GeometryNode", "GeometryNodeCollectionChildren");
11230 define("GeometryNode", "GeometryNodeCollectionInfo");
11231 define("GeometryNode", "GeometryNodeConstructCurves");
11232 define("GeometryNode", "GeometryNodeConvexHull");
11233 define("GeometryNode", "GeometryNodeCornersOfEdge");
11234 define("GeometryNode", "GeometryNodeCornersOfFace");
11235 define("GeometryNode", "GeometryNodeCornersOfVertex");
11236 define("GeometryNode", "GeometryNodeCubeGridTopology");
11237 define("GeometryNode", "GeometryNodeCurveArc");
11238 define("GeometryNode", "GeometryNodeCurveEndpointSelection");
11239 define("GeometryNode", "GeometryNodeCurveHandleTypeSelection", def_geo_curve_handle_type_selection);
11240 define("GeometryNode", "GeometryNodeCurveLength");
11241 define("GeometryNode", "GeometryNodeCurveOfPoint");
11242 define("GeometryNode", "GeometryNodeCurvePrimitiveBezierSegment");
11243 define("GeometryNode", "GeometryNodeCurvePrimitiveCircle");
11244 define("GeometryNode", "GeometryNodeCurvePrimitiveLine");
11245 define("GeometryNode", "GeometryNodeCurvePrimitiveQuadrilateral");
11246 define("GeometryNode", "GeometryNodeCurveQuadraticBezier");
11247 define("GeometryNode", "GeometryNodeCurveSetHandles", def_geo_curve_set_handle_type);
11248 define("GeometryNode", "GeometryNodeCurveSpiral");
11249 define("GeometryNode", "GeometryNodeCurveSplineType");
11250 define("GeometryNode", "GeometryNodeCurveStar");
11251 define("GeometryNode", "GeometryNodeCurvesToGreasePencil");
11252 define("GeometryNode", "GeometryNodeCurveToMesh");
11253 define("GeometryNode", "GeometryNodeCurveToPoints");
11254 define("GeometryNode", "GeometryNodeDeformCurvesOnSurface");
11255 define("GeometryNode", "GeometryNodeDeleteGeometry");
11256 define("GeometryNode", "GeometryNodeDistributePointsInGrid");
11257 define("GeometryNode", "GeometryNodeDistributePointsInVolume");
11258 define("GeometryNode", "GeometryNodeDistributePointsOnFaces", def_geo_distribute_points_on_faces);
11259 define("GeometryNode", "GeometryNodeDualMesh");
11260 define("GeometryNode", "GeometryNodeDuplicateElements");
11261 define("GeometryNode", "GeometryNodeEdgePathsToCurves");
11262 define("GeometryNode", "GeometryNodeEdgePathsToSelection");
11263 define("GeometryNode", "GeometryNodeEdgesOfCorner");
11264 define("GeometryNode", "GeometryNodeEdgesOfVertex");
11265 define("GeometryNode", "GeometryNodeEdgesToFaceGroups");
11266 define("GeometryNode", "GeometryNodeExtrudeMesh");
11267 define("GeometryNode", "GeometryNodeFaceOfCorner");
11268 define("GeometryNode", "GeometryNodeFieldAtIndex");
11269 define("GeometryNode", "GeometryNodeFieldAverage");
11270 define("GeometryNode", "GeometryNodeFieldMinAndMax");
11271 define("GeometryNode", "GeometryNodeFieldOnDomain");
11272 define("GeometryNode", "GeometryNodeFieldToGrid", def_geo_field_to_grid);
11273 define("GeometryNode", "GeometryNodeFieldToList", def_geo_field_to_list);
11274 define("GeometryNode", "GeometryNodeFieldVariance");
11275 define("GeometryNode", "GeometryNodeFillCurve");
11276 define("GeometryNode", "GeometryNodeFilletCurve");
11277 define("GeometryNode", "GeometryNodeFilterList");
11278 define("GeometryNode", "GeometryNodeFlipFaces");
11279 define("GeometryNode", "GeometryNodeForeachGeometryElementInput", def_geo_foreach_geometry_element_input);
11280 define("GeometryNode", "GeometryNodeForeachGeometryElementOutput", def_geo_foreach_geometry_element_output);
11281 define("GeometryNode", "GeometryNodeGeometryToInstance");
11282 define("GeometryNode", "GeometryNodeGetAttributeNames");
11283 define("GeometryNode", "GeometryNodeGetGeometryBundle");
11284 define("GeometryNode", "GeometryNodeGetGeometryComponent");
11285 define("GeometryNode", "GeometryNodeGetGridNames");
11286 define("GeometryNode", "GeometryNodeGetNamedGrid");
11287 define("GeometryNode", "GeometryNodeGizmoDial");
11288 define("GeometryNode", "GeometryNodeGizmoLinear");
11289 define("GeometryNode", "GeometryNodeGizmoTransform", rna_def_geo_gizmo_transform);
11290 define("GeometryNode", "GeometryNodeGreasePencilColor");
11291 define("GeometryNode", "GeometryNodeGreasePencilDrawTime");
11292 define("GeometryNode", "GeometryNodeGreasePencilFillID");
11293 define("GeometryNode", "GeometryNodeGreasePencilOpacity");
11294 define("GeometryNode", "GeometryNodeGreasePencilStrokeSoftness");
11295 define("GeometryNode", "GeometryNodeGreasePencilStrokeVisibility");
11296 define("GeometryNode", "GeometryNodeGreasePencilToCurves");
11297 define("GeometryNode", "GeometryNodeGridAdvect");
11298 define("GeometryNode", "GeometryNodeGridCurl");
11299 define("GeometryNode", "GeometryNodeGridDeactivateVoxels");
11300 define("GeometryNode", "GeometryNodeGridDilateAndErode");
11301 define("GeometryNode", "GeometryNodeGridDivergence");
11302 define("GeometryNode", "GeometryNodeGridGradient");
11303 define("GeometryNode", "GeometryNodeGridInfo");
11304 define("GeometryNode", "GeometryNodeGridLaplacian");
11305 define("GeometryNode", "GeometryNodeGridMean");
11306 define("GeometryNode", "GeometryNodeGridMedian");
11307 define("GeometryNode", "GeometryNodeGridPrune");
11308 define("GeometryNode", "GeometryNodeGridClip");
11309 define("GeometryNode", "GeometryNodeGridSolvePoisson");
11310 define("GeometryNode", "GeometryNodeGridToMesh");
11311 define("GeometryNode", "GeometryNodeGridToPoints");
11312 define("GeometryNode", "GeometryNodeGridTopologyBoolean");
11313 define("GeometryNode", "GeometryNodeGridVoxelize");
11314 define("GeometryNode", "GeometryNodeImageInfo");
11315 define("GeometryNode", "GeometryNodeImageTexture", def_geo_image_texture);
11316 define("GeometryNode", "GeometryNodeImportCSV");
11317 define("GeometryNode", "GeometryNodeImportOBJ");
11318 define("GeometryNode", "GeometryNodeImportPLY");
11319 define("GeometryNode", "GeometryNodeImportSPZ");
11320 define("GeometryNode", "GeometryNodeImportSTL");
11321 define("GeometryNode", "GeometryNodeImportText");
11322 define("GeometryNode", "GeometryNodeImportVDB");
11323 define("GeometryNode", "GeometryNodeIndexOfNearest");
11324 define("GeometryNode", "GeometryNodeCombineList", def_geo_combine_list);
11325 define("GeometryNode", "GeometryNodeIndexSwitch", def_geo_index_switch);
11326 define("GeometryNode", "GeometryNodeInputActiveCamera");
11327 define("GeometryNode", "GeometryNodeInputCollection", def_geo_input_collection);
11328 define("GeometryNode", "GeometryNodeInputCurveHandlePositions");
11329 define("GeometryNode", "GeometryNodeInputCurveTilt");
11330 define("GeometryNode", "GeometryNodeInputEdgeSmooth");
11331 define("GeometryNode", "GeometryNodeInputFont", def_geo_input_font);
11332 define("GeometryNode", "GeometryNodeInputID");
11333 define("GeometryNode", "GeometryNodeInputImage", def_geo_image);
11334 define("GeometryNode", "GeometryNodeInputIndex");
11335 define("GeometryNode", "GeometryNodeInputInstanceBounds");
11336 define("GeometryNode", "GeometryNodeInputInstanceReference");
11337 define("GeometryNode", "GeometryNodeInputInstanceRotation");
11338 define("GeometryNode", "GeometryNodeInputInstanceScale");
11339 define("GeometryNode", "GeometryNodeInputMaterial", def_geo_input_material);
11340 define("GeometryNode", "GeometryNodeInputMaterialIndex");
11341 define("GeometryNode", "GeometryNodeInputMeshEdgeAngle");
11342 define("GeometryNode", "GeometryNodeInputMeshEdgeNeighbors");
11343 define("GeometryNode", "GeometryNodeInputMeshEdgeVertices");
11344 define("GeometryNode", "GeometryNodeInputMeshFaceArea");
11345 define("GeometryNode", "GeometryNodeInputMeshFaceIsPlanar");
11346 define("GeometryNode", "GeometryNodeInputMeshFaceNeighbors");
11347 define("GeometryNode", "GeometryNodeInputMeshIsland");
11348 define("GeometryNode", "GeometryNodeInputMeshVertexNeighbors");
11349 define("GeometryNode", "GeometryNodeInputNamedAttribute");
11350 define("GeometryNode", "GeometryNodeInputNamedLayerSelection");
11351 define("GeometryNode", "GeometryNodeInputNormal", def_geo_input_normal);
11352 define("GeometryNode", "GeometryNodeInputObject", def_geo_input_object);
11353 define("GeometryNode", "GeometryNodeInputPosition");
11354 define("GeometryNode", "GeometryNodeInputRadius");
11355 define("GeometryNode", "GeometryNodeInputSceneTime");
11356 define("GeometryNode", "GeometryNodeInputShadeSmooth");
11357 define("GeometryNode", "GeometryNodeInputShortestEdgePaths");
11358 define("GeometryNode", "GeometryNodeInputSplineCyclic");
11359 define("GeometryNode", "GeometryNodeInputSplineResolution");
11360 define("GeometryNode", "GeometryNodeInputTangent");
11361 define("GeometryNode", "GeometryNodeInputVoxelIndex");
11362 define("GeometryNode", "GeometryNodeInstanceOnPoints");
11363 define("GeometryNode", "GeometryNodeInstancesToPoints");
11364 define("GeometryNode", "GeometryNodeInstanceTransform");
11365 define("GeometryNode", "GeometryNodeInterpolateCurves");
11366 define("GeometryNode", "GeometryNodeIsViewport");
11367 define("GeometryNode", "GeometryNodeJoinGeometry");
11368 define("GeometryNode", "GeometryNodeListGetItem");
11369 define("GeometryNode", "GeometryNodeListLength");
11370 define("GeometryNode", "GeometryNodeGeometryMaterials");
11371 define("GeometryNode", "GeometryNodeMaterialSelection");
11372 define("GeometryNode", "GeometryNodeMenuSwitch", def_geo_menu_switch);
11373 define("GeometryNode", "GeometryNodeMergeByDistance");
11374 define("GeometryNode", "GeometryNodeMergeLayers", def_geo_merge_layers);
11375 define("GeometryNode", "GeometryNodeMergePoints");
11376 define("GeometryNode", "GeometryNodeMeshBevel");
11377 define("GeometryNode", "GeometryNodeMeshBoolean");
11378 define("GeometryNode", "GeometryNodeMeshCircle");
11379 define("GeometryNode", "GeometryNodeMeshCone");
11380 define("GeometryNode", "GeometryNodeMeshCube");
11381 define("GeometryNode", "GeometryNodeMeshCylinder");
11382 define("GeometryNode", "GeometryNodeMeshFaceSetBoundaries");
11383 define("GeometryNode", "GeometryNodeMeshGrid");
11384 define("GeometryNode", "GeometryNodeMeshIcoSphere");
11385 define("GeometryNode", "GeometryNodeMeshLine");
11386 define("GeometryNode", "GeometryNodeMeshToCurve");
11387 define("GeometryNode", "GeometryNodeMeshToDensityGrid");
11388 define("GeometryNode", "GeometryNodeMeshToPoints");
11389 define("GeometryNode", "GeometryNodeMeshToSDFGrid");
11390 define("GeometryNode", "GeometryNodeMeshToVolume");
11391 define("GeometryNode", "GeometryNodeMeshUVSphere");
11392 define("GeometryNode", "GeometryNodeNURBSOrder");
11393 define("GeometryNode", "GeometryNodeNURBSWeight");
11394 define("GeometryNode", "GeometryNodeObjectInfo");
11395 define("GeometryNode", "GeometryNodeOffsetCornerInFace");
11396 define("GeometryNode", "GeometryNodeOffsetPointInCurve");
11397 define("GeometryNode", "GeometryNodePoints");
11398 define("GeometryNode", "GeometryNodePointsOfCurve");
11399 define("GeometryNode", "GeometryNodePointsSetType");
11400 define("GeometryNode", "GeometryNodePointsToCurves");
11401 define("GeometryNode", "GeometryNodePointsToSDFGrid");
11402 define("GeometryNode", "GeometryNodePointsToVertices");
11403 define("GeometryNode", "GeometryNodePointsToVolume");
11404 define("GeometryNode", "GeometryNodeProximity");
11405 define("GeometryNode", "GeometryNodeRasterizePoints", def_geo_rasterize_points);
11406 define("GeometryNode", "GeometryNodeRaycast");
11407 define("GeometryNode", "GeometryNodeRealizeInstances");
11408 define("GeometryNode", "GeometryNodeRemoveAttribute");
11409 define("GeometryNode", "GeometryNodeRenameAttribute");
11410 define("GeometryNode", "GeometryNodeRepeatInput", def_geo_repeat_input);
11411 define("GeometryNode", "GeometryNodeRepeatOutput", def_geo_repeat_output);
11412 define("GeometryNode", "GeometryNodeReplaceMaterial");
11413 define("GeometryNode", "GeometryNodeResampleCurve");
11414 define("GeometryNode", "GeometryNodeReverseCurve");
11415 define("GeometryNode", "GeometryNodeRotateInstances");
11416 define("GeometryNode", "GeometryNodeSampleCurve", def_geo_curve_sample);
11417 define("GeometryNode", "GeometryNodeSampleGrid");
11418 define("GeometryNode", "GeometryNodeSampleGridIndex");
11419 define("GeometryNode", "GeometryNodeSampleIndex", def_geo_sample_index);
11420 define("GeometryNode", "GeometryNodeSampleNearest");
11421 define("GeometryNode", "GeometryNodeSampleNearestSurface");
11422 define("GeometryNode", "GeometryNodeSampleSoundFrequencies");
11423 define("GeometryNode", "GeometryNodeSampleUVSurface");
11424 define("GeometryNode", "GeometryNodeScaleElements");
11425 define("GeometryNode", "GeometryNodeScaleInstances");
11426 define("GeometryNode", "GeometryNodeSDFGridBoolean");
11427 define("GeometryNode", "GeometryNodeSDFGridFillet");
11428 define("GeometryNode", "GeometryNodeSDFGridLaplacian");
11429 define("GeometryNode", "GeometryNodeSDFGridMean");
11430 define("GeometryNode", "GeometryNodeSDFGridMeanCurvature");
11431 define("GeometryNode", "GeometryNodeSDFGridMedian");
11432 define("GeometryNode", "GeometryNodeSDFGridOffset");
11433 define("GeometryNode", "GeometryNodeSelfObject");
11434 define("GeometryNode", "GeometryNodeSeparateComponents");
11435 define("GeometryNode", "GeometryNodeSeparateGeometry");
11436 define("GeometryNode", "GeometryNodeSetCurveHandlePositions");
11437 define("GeometryNode", "GeometryNodeSetCurveNormal");
11438 define("GeometryNode", "GeometryNodeSetCurveRadius");
11439 define("GeometryNode", "GeometryNodeSetCurveTilt");
11440 define("GeometryNode", "GeometryNodeSetGeometryBundle");
11441 define("GeometryNode", "GeometryNodeSetGeometryName");
11442 define("GeometryNode", "GeometryNodeSetGreasePencilColor", def_geo_set_grease_pencil_color);
11443 define("GeometryNode", "GeometryNodeSetGreasePencilDepth", def_geo_set_grease_pencil_depth);
11444 define("GeometryNode", "GeometryNodeSetGreasePencilSoftness");
11445 define("GeometryNode", "GeometryNodeSetGridBackground");
11446 define("GeometryNode", "GeometryNodeSetGridTransform");
11447 define("GeometryNode", "GeometryNodeSetID");
11448 define("GeometryNode", "GeometryNodeSetInstanceTransform");
11449 define("GeometryNode", "GeometryNodeSetMaterial");
11450 define("GeometryNode", "GeometryNodeSetMaterialIndex");
11451 define("GeometryNode", "GeometryNodeSetMeshNormal");
11452 define("GeometryNode", "GeometryNodeSetNURBSOrder");
11453 define("GeometryNode", "GeometryNodeSetNURBSWeight");
11454 define("GeometryNode", "GeometryNodeSetPointRadius");
11455 define("GeometryNode", "GeometryNodeSetPosition");
11456 define("GeometryNode", "GeometryNodeSetShadeSmooth");
11457 define("GeometryNode", "GeometryNodeSetSplineCyclic");
11458 define("GeometryNode", "GeometryNodeSetSplineResolution");
11459 define("GeometryNode", "GeometryNodeSimulationInput", def_geo_simulation_input);
11460 define("GeometryNode", "GeometryNodeSimulationOutput", def_geo_simulation_output);
11461 define("GeometryNode", "GeometryNodeSortElements");
11462 define("GeometryNode", "GeometryNodeSortList");
11463 define("GeometryNode", "GeometryNodeSplineLength");
11464 define("GeometryNode", "GeometryNodeSplineParameter");
11465 define("GeometryNode", "GeometryNodeSplitEdges");
11466 define("GeometryNode", "GeometryNodeSplitToInstances");
11467 define("GeometryNode", "GeometryNodeStoreNamedAttribute");
11468 define("GeometryNode", "GeometryNodeStoreNamedGrid");
11469 define("GeometryNode", "GeometryNodeStringJoin");
11470 define("GeometryNode", "GeometryNodeStringToCurves");
11471 define("GeometryNode", "GeometryNodeSubdivideCurve");
11472 define("GeometryNode", "GeometryNodeSubdivideMesh");
11473 define("GeometryNode", "GeometryNodeSubdivisionSurface");
11474 define("GeometryNode", "GeometryNodeSwitch");
11475 define("GeometryNode", "GeometryNodeTagFilter");
11476 define("GeometryNode", "GeometryNodeTool3DCursor");
11477 define("GeometryNode", "GeometryNodeToolActiveElement");
11478 define("GeometryNode", "GeometryNodeToolFaceSet");
11479 define("GeometryNode", "GeometryNodeToolMousePosition");
11480 define("GeometryNode", "GeometryNodeToolSelection");
11481 define("GeometryNode", "GeometryNodeToolSetFaceSet");
11482 define("GeometryNode", "GeometryNodeToolSetSelection");
11483 define("GeometryNode", "GeometryNodeTransform");
11484 define("GeometryNode", "GeometryNodeTranslateInstances");
11485 define("GeometryNode", "GeometryNodeTransferAttributes");
11486 define("GeometryNode", "GeometryNodeTriangulate");
11487 define("GeometryNode", "GeometryNodeTrimCurve");
11488 define("GeometryNode", "GeometryNodeUVPackIslands");
11489 define("GeometryNode", "GeometryNodeUVTangent");
11490 define("GeometryNode", "GeometryNodeUVUnwrap");
11491 define("GeometryNode", "GeometryNodeVertexOfCorner");
11492 define("GeometryNode", "GeometryNodeViewer", rna_def_geo_viewer);
11493 define("GeometryNode", "GeometryNodeViewportTransform");
11494 define("GeometryNode", "GeometryNodeVolumeCube");
11495 define("GeometryNode", "GeometryNodeVolumeToMesh");
11496 define("GeometryNode", "GeometryNodeWarning");
11497 define("GeometryNode", "GeometryNodeXPBDSolver");
11498
11499
11500 /* Node group types are currently defined for each tree type individually. */
11501 define("ShaderNode", "ShaderNodeGroup", def_group);
11502 define("CompositorNode", "CompositorNodeGroup", def_group);
11503 define("TextureNode", "TextureNodeGroup", def_group);
11504 define("GeometryNode", "GeometryNodeGroup", def_group);
11505
11506 /* clang-format on */
11507}
11508
11510{
11512 rna_def_node(brna);
11514 rna_def_node_link(brna);
11515
11517 rna_def_shader_node(brna);
11522
11523 rna_def_nodetree(brna);
11524
11529
11530 rna_def_nodes(brna);
11531
11532 def_custom_group(brna,
11533 "ShaderNodeCustomGroup",
11534 "ShaderNode",
11535 "Shader Custom Group",
11536 "Custom Shader Group Node for Python nodes",
11537 "rna_ShaderNodeCustomGroup_register");
11538 def_custom_group(brna,
11539 "CompositorNodeCustomGroup",
11540 "CompositorNode",
11541 "Compositor Custom Group",
11542 "Custom Compositor Group Node for Python nodes",
11543 "rna_CompositorNodeCustomGroup_register");
11544 def_custom_group(brna,
11545 "NodeCustomGroup",
11546 "Node",
11547 "Custom Group",
11548 "Base node type for custom registered node group types",
11549 "rna_NodeCustomGroup_register");
11550 def_custom_group(brna,
11551 "GeometryNodeCustomGroup",
11552 "GeometryNode",
11553 "Geometry Custom Group",
11554 "Custom Geometry Group Node for Python nodes",
11555 "rna_GeometryNodeCustomGroup_register");
11556}
11557
11558/* clean up macro definition */
11559# undef NODE_DEFINE_SUBTYPES
11560
11561} // namespace blender
11562
11563#endif
#define G_MAIN
#define IMA_SIGNAL_SRC_CHANGE
Definition BKE_image.hh:181
#define SELECT
Definition BKE_mask.hh:19
#define NODE_CLASS_OUTPUT
Definition BKE_node.hh:479
#define NODE_UNDEFINED
Definition BKE_node.hh:863
#define NODE_CUSTOM_GROUP
Definition BKE_node.hh:870
#define NODE_CUSTOM
Definition BKE_node.hh:864
#define SH_NODE_TEX_IMAGE
#define CMP_NODE_CRYPTOMATTE
#define SH_NODE_MAP_RANGE
#define SH_NODE_TEX_ENVIRONMENT
#define CMP_NODE_OUTPUT_FILE
#define SH_NODE_MIX
#define SH_NODE_SCRIPT
#define INT32_MAX
#define DEG2RADF(_deg)
#define M_PI_2
#define BLI_SCOPED_DEFER(function_to_defer)
#define SNPRINTF(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define BLT_I18NCONTEXT_COLOR_MANAGEMENT
#define CTX_N_(context, msgid)
#define BLT_I18NCONTEXT_ID_NODETREE
#define BLT_I18NCONTEXT_ID_IMAGE
#define BLT_I18NCONTEXT_OPERATOR_DEFAULT
#define BLT_I18NCONTEXT_UNIT
#define BLT_I18NCONTEXT_ID_MOVIECLIP
#define BLT_I18NCONTEXT_ID_TEXTURE
#define ID_BLEND_PATH_FROM_GLOBAL(_id)
Definition DNA_ID.h:691
#define MAX_NAME
Definition DNA_defs.h:63
#define SHD_SHEEN_ASHIKHMIN
#define SHD_SHEEN_MICROFIBER
Object is a sort of wrapper for general info.
#define MAXFRAMEF
#define MINAFRAMEF
#define RNA_MAX_ARRAY_DIMENSION
Definition RNA_define.hh:29
#define RNA_ENUM_ITEM_SEPR
Definition RNA_types.hh:762
#define RNA_ENUM_ITEM_HEADING(name, description)
Definition RNA_types.hh:759
#define C
Definition RandGen.cpp:29
#define NC_WINDOW
Definition WM_types.hh:388
#define NC_NODE
Definition WM_types.hh:407
#define ND_OB_ACTIVE
Definition WM_types.hh:459
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_SCENE
Definition WM_types.hh:391
#define ND_NODES
Definition WM_types.hh:455
#define NA_EDITED
Definition WM_types.hh:634
#define NC_IMAGE
Definition WM_types.hh:397
#define ND_NODE_ASSET_DATA
Definition WM_types.hh:558
#define NA_SELECTED
Definition WM_types.hh:639
#define CLAMP(a, b, c)
#define STREQLEN(a, b, n)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
#define STREQ(a, b)
btScalar max
SIMD_FORCE_INLINE btScalar length() const
Return the length of the vector.
Definition btVector3.h:257
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool contains(int64_t value) const
StringRefNull copy_string(StringRef str)
constexpr StringRef()
int64_t size() const
const char * c_str() const
StringRefNull ref() const
UString()=default
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
std::shared_ptr< const nodes::GeometryNodesLazyFunctionGraphInfo > geometry_nodes_lazy_function_graph_info
void copy_unsafe(char *dst) const
constexpr const char * c_str() const
#define FLT_MAX
#define INT_MAX
#define storage(slot, qualifiers)
#define layer
void free(Subdiv *subdiv)
Definition subdiv.cc:192
NodeColorTag node_color_tag(const bNode &node)
Definition node.cc:5788
void node_tree_set_output(bNodeTree &ntree)
Definition node.cc:5238
const bNodeZoneType * zone_type_by_node_type(const int node_type)
bool node_is_parent_and_child(const bNode &parent, const bNode &child)
Definition node.cc:4115
void node_attach_node(bNodeTree &ntree, bNode &node, bNode &parent)
Definition node.cc:4883
bool node_tree_is_registered(const bNodeTree &ntree)
Definition node.cc:2873
bNodeTreeType * node_tree_type_find(StringRef idname)
Definition node.cc:2797
Span< bNodeSocketType * > node_socket_types_get()
Definition node.cc:2961
void node_tag_update_id(bNode &node)
Definition node.cc:5593
void node_remove_node(Main *bmain, bNodeTree &ntree, bNode &node, bool do_id_user, bool remove_animation=true)
Definition node.cc:5155
bNode * node_get_active(bNodeTree &ntree)
Definition node.cc:5445
void node_remove_socket(bNodeTree &ntree, bNode &node, bNodeSocket &sock)
Definition node.cc:4015
void node_update_asset_metadata(bNodeTree &node_tree)
Definition node.cc:2462
bool node_group_poll(const bNodeTree *nodetree, const bNodeTree *grouptree, const char **r_disabled_hint)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
const char * node_socket_translation_context(const bNodeSocket &sock)
Definition node.cc:5770
void node_remove_link(bNodeTree *ntree, bNodeLink &link)
Definition node.cc:4676
bNode * node_add_node(const bContext *C, bNodeTree &ntree, UString idname, std::optional< int > unique_identifier=std::nullopt)
Definition node.cc:4260
void node_tree_type_add(bNodeTreeType &nt)
Definition node.cc:2844
bNodeType * node_type_find(UString idname)
Definition node.cc:2883
int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock)
Definition node.cc:5434
bNode * node_find_node_try(bNodeTree &ntree, bNodeSocket &socket)
Definition node.cc:4065
void node_tree_type_free_link(const bNodeTreeType &nt)
Definition node.cc:2867
bool node_set_selected(bNode &node, bool select)
Definition node.cc:5455
bNodeSocket * node_add_socket(bNodeTree &ntree, bNode &node, eNodeSocketInOut in_out, StringRefNull idname, StringRefNull identifier, StringRefNull name)
Definition node.cc:3461
bool node_tree_contains_tree(const bNodeTree &tree_to_search_in, const bNodeTree &tree_to_search_for)
Definition node.cc:5423
void node_detach_node(bNodeTree &ntree, bNode &node)
Definition node.cc:4891
bNodeSocketType * node_socket_type_find(StringRef idname)
Definition node.cc:2966
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
UString node_type_find_alias(UString alias)
Definition node.cc:2892
bNodeSocketType * node_socket_type_find_static(int type, int subtype=0)
Definition node.cc:2975
StringRefNull node_socket_type_label(const bNodeSocketType &stype)
Definition node.cc:3018
Span< bNodeTreeType * > node_tree_types_get()
Definition node.cc:2878
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
Definition node.cc:3036
void node_unregister_type(bNodeType &ntype)
Definition node.cc:2945
std::optional< StringRefNull > node_static_socket_type(int type, int subtype, std::optional< int > dimensions=std::nullopt)
Definition node.cc:3492
void node_remove_socket_links(bNodeTree &ntree, bNodeSocket &sock)
Definition node.cc:4702
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
float2 node_dimensions_get(const bNode &node)
Definition node.cc:5587
int node_socket_link_limit(const bNodeSocket &sock)
Definition node.cc:5513
void node_clear_active(bNodeTree &ntree)
Definition node.cc:5477
void node_unique_name(bNodeTree &ntree, bNode &node)
Definition node.cc:4238
bool node_link_is_hidden(const bNodeLink &link)
Definition node.cc:4711
void node_type_base_custom(bNodeType &ntype, StringRefNull idname, StringRefNull name, StringRefNull enum_name, short nclass)
Definition node.cc:5896
void remove_index(T **items, int *items_num, int *active_index, const int index, void(*destruct_item)(T *))
void clear(T **items, int *items_num, int *active_index, void(*destruct_item)(T *))
void move_index(T *items, const int items_num, const int from_index, const int to_index)
bool generic_attribute_type_supported(const EnumPropertyItem &item)
void set_item_name_and_make_unique(bNode &node, typename Accessor::ItemT &item, const char *value)
Accessor::ItemT * add_item_with_name(bNode &node, const char *name)
Accessor::ItemT * add_item(bNode &node)
bNode * find_node_by_item(bNodeTree &ntree, const typename Accessor::ItemT &item)
Accessor::ItemT * add_item_with_socket_type_and_name(bNodeTree &ntree, bNode &node, const eNodeSocketDatatype socket_type, const char *name, std::optional< int > dimensions=std::nullopt)
bool socket_type_supports_fields(const eNodeSocketDatatype socket_type)
bool socket_type_supports_grids(const eNodeSocketDatatype socket_type)
void refresh_for_srna_unregister(Main *bmain, StructRNA *srna_to_unreg)
BMesh Iterators.
@ SHD_PHASE_HENYEY_GREENSTEIN
@ SHD_PHASE_FOURNIER_FORAND
static void rna_def_nodes(BlenderRNA *brna)
static void def_colorramp(BlenderRNA *, StructRNA *srna)
void WM_main_add_notifier(uint type, void *reference)
CompositorNodeAssetTraitFlag
@ COMPOSIT_NODE_ASSET_STRIP_MODIFIER
@ COMPOSIT_NODE_ASSET_SCENE_EFFECT
static void def_tex_output(BlenderRNA *, StructRNA *srna)
void RNA_def_property_srna(PropertyRNA *prop, const char *type)
static void def_sh_vertex_color(BlenderRNA *, StructRNA *srna)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
static void def_tex_combsep_color(BlenderRNA *, StructRNA *srna)
@ NODE_GEO_VIEWER_ITEM_FLAG_AUTO_REMOVE
static const EnumPropertyItem prop_view_layer_items[]
static void def_principled(BlenderRNA *, StructRNA *srna)
void rna_Node_Viewer_shortcut_node_set(PointerRNA *ptr, PropertyRNA *prop, int value)
const EnumPropertyItem * rna_node_socket_type_itemf(void *data, bool(*poll)(void *data, bke::bNodeSocketType *), bool *r_free)
static void def_geo_closure_to_list(BlenderRNA *brna, StructRNA *srna)
static void rna_def_node_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int in_out)
static void rna_def_node_item_array_socket_item_common(StructRNA *srna, const char *accessor, const bool add_socket_type, const bool add_vector_socket_dimensions=false)
static void rna_def_geo_index_switch_items(BlenderRNA *brna)
@ SHD_PRINCIPLED_HAIR_CHIANG
@ SHD_PRINCIPLED_HAIR_HUANG
@ SHD_WAVE_BANDS_DIRECTION_Z
@ SHD_WAVE_BANDS_DIRECTION_DIAGONAL
@ SHD_WAVE_BANDS_DIRECTION_X
@ SHD_WAVE_BANDS_DIRECTION_Y
static void def_fn_input_int(BlenderRNA *, StructRNA *srna)
void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item)
@ NODE_ACTIVE_TEXTURE
static void def_sh_tex(BlenderRNA *, StructRNA *srna)
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
void RNA_def_property_deprecated(PropertyRNA *prop, const char *note, const short version, const short removal_version)
static void def_sh_normal_map(BlenderRNA *, StructRNA *srna)
char * STRNCPY(char(&dst)[N], const char *src)
@ NODE_MAPPING_TYPE_VECTOR
@ NODE_MAPPING_TYPE_POINT
@ NODE_MAPPING_TYPE_NORMAL
@ NODE_MAPPING_TYPE_TEXTURE
void IMB_colormanagement_colorspace_items_add(EnumPropertyItem **items, int *totitem)
void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
@ GEO_NODE_GREASE_PENCIL_STROKE
@ GEO_NODE_GREASE_PENCIL_FILL
@ GEO_NODE_GREASE_PENCIL_BOTH
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
int(*)(PointerRNA *ptr, void *data, bool *have_function) StructValidateFunc
const EnumPropertyItem rna_enum_node_compare_operation_items[]
const EnumPropertyItem rna_enum_node_socket_type_items[]
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
static void def_sh_attribute(BlenderRNA *, StructRNA *srna)
static void def_fn_random_value(BlenderRNA *, StructRNA *srna)
static void rna_def_internal_node(BlenderRNA *brna)
@ IMA_TYPE_MULTILAYER
void RNA_def_function_output(FunctionRNA *, PropertyRNA *ret)
@ RPT_ERROR_INVALID_INPUT
Definition BKE_report.hh:42
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
static void def_sh_output_aov(BlenderRNA *, StructRNA *srna)
static void def_time(BlenderRNA *, StructRNA *srna)
void RNA_def_property_enum_default(PropertyRNA *prop, int value)
static void def_sh_combsep_color(BlenderRNA *, StructRNA *srna)
static void rna_def_node_link(BlenderRNA *brna)
static void def_fn_format_string(BlenderRNA *brna, StructRNA *srna)
static void def_sh_mix(BlenderRNA *, StructRNA *srna)
static void def_cmp_stabilize2d(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_color_space_interop_id_default_items[]
Definition rna_color.cc:35
static void def_sh_uvalongstroke(BlenderRNA *, StructRNA *srna)
static void def_sh_radial_tiling(BlenderRNA *, StructRNA *srna)
static void def_metallic(BlenderRNA *, StructRNA *srna)
static void def_geo_distribute_points_on_faces(BlenderRNA *, StructRNA *srna)
static void def_cmp_render_layers(BlenderRNA *, StructRNA *srna)
int IMB_colormanagement_colorspace_get_named_index(const char *name)
static void def_geo_foreach_geometry_element_input(BlenderRNA *brna, StructRNA *srna)
int rna_node_tree_idname_to_enum(const char *idname)
void BKE_ntree_update_tag_link_changed(bNodeTree *ntree)
static void rna_def_nodetree(BlenderRNA *brna)
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
@ SHD_NOISE_RIDGED_MULTIFRACTAL
@ SHD_NOISE_HETERO_TERRAIN
@ SHD_NOISE_HYBRID_MULTIFRACTAL
@ SHD_NOISE_MULTIFRACTAL
static void rna_def_geo_bake(BlenderRNA *brna, StructRNA *srna)
@ SHD_IMAGE_EXTENSION_EXTEND
@ SHD_IMAGE_EXTENSION_CLIP
@ SHD_IMAGE_EXTENSION_MIRROR
@ SHD_IMAGE_EXTENSION_REPEAT
static void def_sh_vector_displacement(BlenderRNA *, StructRNA *srna)
static void def_geo_rasterize_points(BlenderRNA *brna, StructRNA *srna)
int node_group_ui_class(const bNode *node)
bool RE_layers_have_name(RenderResult *result)
static void def_sh_tangent(BlenderRNA *, StructRNA *srna)
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
static void def_sh_mapping(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_node_compositor_extension_items[]
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static const EnumPropertyItem node_cryptomatte_layer_name_items[]
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
@ NODE_CLOSURE_FLAG_DEFINE_SIGNATURE
void id_us_plus(ID *id)
Definition lib_id.cc:433
static const EnumPropertyItem rna_enum_vector_rotate_type_items[]
void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
static void def_geo_input_object(BlenderRNA *, StructRNA *srna)
static void rna_def_geometry_nodetree(BlenderRNA *brna)
PointerRNA RNA_id_pointer_create(ID *id)
@ NODE_MAP_RANGE_SMOOTHERSTEP
@ NODE_MAP_RANGE_LINEAR
@ NODE_MAP_RANGE_SMOOTHSTEP
@ NODE_MAP_RANGE_STEPPED
static void def_combine_bundle(BlenderRNA *brna, StructRNA *srna)
static void rna_def_geo_capture_attribute_items(BlenderRNA *brna)
static void def_geo_index_switch(BlenderRNA *brna, StructRNA *srna)
void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
const char * IMB_colormanagement_colorspace_get_indexed_name(int index)
static void rna_def_geo_combine_list_items(BlenderRNA *brna)
static void def_geo_curve_set_handle_type(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_ramp_blend_items[]
MINLINE void copy_v2_v2(float r[2], const float a[2])
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
static void def_fn_input_int_vector(BlenderRNA *, StructRNA *srna)
void RNA_def_struct_system_idprops_func(StructRNA *srna, const char *system_idproperties)
@ SHD_ATTRIBUTE_INSTANCER
@ SHD_ATTRIBUTE_LIGHT
@ SHD_ATTRIBUTE_VIEW_LAYER
@ SHD_ATTRIBUTE_GEOMETRY
@ SHD_ATTRIBUTE_OBJECT
static void rna_def_composite_nodetree(BlenderRNA *brna)
static void def_geo_field_to_list(BlenderRNA *brna, StructRNA *srna)
static const EnumPropertyItem node_principled_distribution_items[]
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
@ SHD_NORMAL_MAP_CONVENTION_DIRECTX
@ SHD_NORMAL_MAP_CONVENTION_OPENGL
static void def_geo_field_to_grid(BlenderRNA *brna, StructRNA *srna)
static void rna_def_geo_rasterize_points_items(BlenderRNA *brna)
const EnumPropertyItem rna_enum_geometry_nodes_gizmo_color_items[]
static void rna_def_geo_foreach_geometry_element_generation_items(BlenderRNA *brna)
@ CMP_NODE_COMBSEP_COLOR_HSL
@ CMP_NODE_COMBSEP_COLOR_YCC
@ CMP_NODE_COMBSEP_COLOR_YUV
@ CMP_NODE_COMBSEP_COLOR_HSV
@ CMP_NODE_COMBSEP_COLOR_RGB
std::string RNA_path_name_to_infix(const StringRefNull string)
Definition rna_path.cc:1419
@ FN_NODE_ROTATE_EULER_SPACE_OBJECT
@ FN_NODE_ROTATE_EULER_SPACE_LOCAL
@ GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_POISSON
@ GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM
static void def_group(BlenderRNA *, StructRNA *srna)
static void def_cmp_viewer(BlenderRNA *, StructRNA *srna)
@ FUNC_USE_SELF_TYPE
@ FUNC_ALLOW_WRITE
@ FUNC_USE_REPORTS
@ FUNC_USE_SELF_ID
Definition RNA_types.hh:980
@ FUNC_USE_MAIN
@ FUNC_NO_SELF
Definition RNA_types.hh:998
@ FUNC_REGISTER_OPTIONAL
@ FUNC_REGISTER
@ FUNC_USE_CONTEXT
@ GEO_NODE_CURVE_HANDLE_FREE
@ GEO_NODE_CURVE_HANDLE_AUTO
@ GEO_NODE_CURVE_HANDLE_VECTOR
@ GEO_NODE_CURVE_HANDLE_ALIGN
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void * RNA_struct_blender_type_get(StructRNA *srna)
void RNA_def_property_path_template_type(PropertyRNA *prop, PropertyPathTemplateType path_template_type)
@ SHD_VECT_TRANSFORM_TYPE_POINT
@ SHD_VECT_TRANSFORM_TYPE_NORMAL
@ SHD_VECT_TRANSFORM_TYPE_VECTOR
static void rna_def_fn_format_string_items(BlenderRNA *brna)
static void def_hair_principled(BlenderRNA *, StructRNA *srna)
static void def_toon(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem node_hair_items[]
@ 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
static void rna_def_closure_input_item(BlenderRNA *brna)
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
static const EnumPropertyItem node_script_mode_items[]
static void rna_def_node_internal_link(BlenderRNA *brna)
void RNA_def_property_flag_hide_from_ui_workaround(PropertyRNA *prop)
static const EnumPropertyItem node_metallic_distribution_items[]
void rna_pointer_create_with_ancestors(const PointerRNA &parent, StructRNA *type, void *data, PointerRNA &r_ptr)
static void rna_def_shader_nodetree(BlenderRNA *brna)
static void def_geo_set_grease_pencil_depth(BlenderRNA *, StructRNA *srna)
GeometryNodeAssetTraitFlag
@ GEO_NODE_ASSET_HIDE_MODIFIER_MANAGE_PANEL
@ GEO_NODE_ASSET_PAINT
@ GEO_NODE_ASSET_GREASE_PENCIL
@ GEO_NODE_ASSET_CURVE
@ GEO_NODE_ASSET_EDIT
@ GEO_NODE_ASSET_MESH
@ GEO_NODE_ASSET_WAIT_FOR_CURSOR
@ GEO_NODE_ASSET_POINTCLOUD
@ GEO_NODE_ASSET_SCULPT
@ GEO_NODE_ASSET_OBJECT
@ GEO_NODE_ASSET_TOOL
@ GEO_NODE_ASSET_MODIFIER
static void def_sh_output(BlenderRNA *, StructRNA *srna)
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
static const EnumPropertyItem node_glossy_items[]
const char * RE_engine_id_CYCLES
Definition scene.cc:1720
static const EnumPropertyItem rna_enum_mix_data_type_items[]
static void def_sh_tex_magic(BlenderRNA *brna, StructRNA *srna)
static void def_sh_bump(BlenderRNA *, StructRNA *srna)
static void def_cmp_image(BlenderRNA *brna, StructRNA *srna)
@ SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION
@ SHD_PRINCIPLED_HAIR_REFLECTANCE
@ SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION
static void def_fn_rotate_euler(BlenderRNA *, StructRNA *srna)
@ GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Y
@ GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_X
@ GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Z
@ GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_X
@ GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Y
@ GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Z
@ GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_X
@ GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Y
@ GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Z
@ NODE_COMBSEP_COLOR_HSL
@ NODE_COMBSEP_COLOR_HSV
@ NODE_COMBSEP_COLOR_RGB
@ NODE_INTEGER_MATH_DIVIDE
@ NODE_INTEGER_MATH_LCM
@ NODE_INTEGER_MATH_DIVIDE_CEIL
@ NODE_INTEGER_MATH_MODULO
@ NODE_INTEGER_MATH_FLOORED_MODULO
@ NODE_INTEGER_MATH_MULTIPLY_ADD
@ NODE_INTEGER_MATH_DIVIDE_ROUND
@ NODE_INTEGER_MATH_GCD
@ NODE_INTEGER_MATH_ADD
@ NODE_INTEGER_MATH_MULTIPLY
@ NODE_INTEGER_MATH_MINIMUM
@ NODE_INTEGER_MATH_ABSOLUTE
@ NODE_INTEGER_MATH_POWER
@ NODE_INTEGER_MATH_NEGATE
@ NODE_INTEGER_MATH_MAXIMUM
@ NODE_INTEGER_MATH_SUBTRACT
@ NODE_INTEGER_MATH_SIGN
@ NODE_INTEGER_MATH_DIVIDE_FLOOR
static void rna_def_nodetree_link_api(BlenderRNA *brna, PropertyRNA *cprop)
static const EnumPropertyItem node_subsurface_method_items[]
static void def_sh_tex_coord(BlenderRNA *, StructRNA *srna)
static void def_geo_image_texture(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_node_float_to_int_items[]
const EnumPropertyItem * rna_NodeSocket_structure_type_item_filter(const bNodeTree *ntree, const eNodeSocketDatatype socket_type, bool *r_free)
static void def_sh_tex_white_noise(BlenderRNA *, StructRNA *srna)
static void rna_def_evaluate_closure_input_items(BlenderRNA *brna)
void IMB_colormanagement_colorspace_interop_id_set(char *name, char *interop_id, int index)
void ED_node_type_draw_color(const char *idname, float *r_color)
Definition drawnode.cc:1699
const EnumPropertyItem rna_enum_stroke_depth_order_items[]
@ SHD_PHYSICAL_CONDUCTOR
void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static const EnumPropertyItem rna_enum_shader_attribute_type_items[]
static void def_clamp(BlenderRNA *, StructRNA *srna)
static void rna_def_geo_capture_attribute_item(BlenderRNA *brna)
const EnumPropertyItem rna_enum_mapping_type_items[]
const EnumPropertyItem rna_enum_node_grease_pencil_stroke_type_items[]
@ PROP_VARIABLES_RENDER_OUTPUT
Definition RNA_types.hh:572
static void def_cmp_cryptomatte_common(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem rna_node_geometry_curve_handle_type_items[]
@ NODE_EVALUATE_CLOSURE_FLAG_DEFINE_SIGNATURE
static void def_evaluate_closure(BlenderRNA *brna, StructRNA *srna)
@ SHD_NORMAL_MAP_BASE_DISPLACED
@ SHD_NORMAL_MAP_BASE_ORIGINAL
static void def_fn_input_rotation(BlenderRNA *, StructRNA *srna)
void BKE_scene_graph_evaluated_ensure(Depsgraph *depsgraph, Main *bmain)
Definition scene.cc:2872
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
@ NODE_BOOLEAN_MATH_XOR
@ NODE_BOOLEAN_MATH_NIMPLY
@ NODE_BOOLEAN_MATH_NAND
@ NODE_BOOLEAN_MATH_AND
@ NODE_BOOLEAN_MATH_IMPLY
@ NODE_BOOLEAN_MATH_OR
@ NODE_BOOLEAN_MATH_NOT
@ NODE_BOOLEAN_MATH_NOR
@ NODE_BOOLEAN_MATH_XNOR
static void rna_def_geo_field_to_list_item(BlenderRNA *brna)
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
@ FN_NODE_FLOAT_TO_INT_FLOOR
@ FN_NODE_FLOAT_TO_INT_CEIL
@ FN_NODE_FLOAT_TO_INT_TRUNCATE
@ FN_NODE_FLOAT_TO_INT_ROUND
static void def_cmp_cryptomatte_entry(BlenderRNA *brna)
static void rna_def_combine_bundle_items(BlenderRNA *brna)
@ PROPOVERRIDE_OVERRIDABLE_LIBRARY
Definition RNA_types.hh:588
@ PROPOVERRIDE_IGNORE
Definition RNA_types.hh:609
@ PROPOVERRIDE_NO_COMPARISON
Definition RNA_types.hh:596
static void def_fn_input_bool(BlenderRNA *, StructRNA *srna)
static void rna_def_node(BlenderRNA *brna)
void RNA_def_property_float_default(PropertyRNA *prop, float value)
ParameterList * RNA_parameter_list_create(ParameterList *parms, PointerRNA *, FunctionRNA *func)
bool DEG_is_original(const T *id)
static void def_rgb_curve(BlenderRNA *, StructRNA *srna)
void rna_def_animdata_common(StructRNA *srna)
void BKE_animdata_fix_paths(ID &id, StringRef prefix, StringRef old_infix, StringRef new_infix, bool verify_paths, const DriverMap &driver_map)
static void def_sh_script(BlenderRNA *, StructRNA *srna)
void RE_engine_free(RenderEngine *engine)
void IMB_colormanagement_interop_id_items_add(EnumPropertyItem **items, int *totitem)
static void rna_def_function_node(BlenderRNA *brna)
static void rna_def_nodetree_nodes_api(BlenderRNA *brna, PropertyRNA *cprop)
@ NODE_WARNING_PROPAGATION_NONE
@ NODE_WARNING_PROPAGATION_ONLY_ERRORS_AND_WARNINGS
@ NODE_WARNING_PROPAGATION_ALL
@ NODE_WARNING_PROPAGATION_ONLY_ERRORS
const EnumPropertyItem * RNA_node_enum_definition_itemf(const bke::RuntimeNodeEnumItems &enum_items, bool *r_free)
static void def_frame(BlenderRNA *, StructRNA *srna)
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
static void def_map_range(BlenderRNA *, StructRNA *srna)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
static void def_volume_coefficients(BlenderRNA *, StructRNA *srna)
static void rna_def_separate_bundle_item(BlenderRNA *brna)
static void def_sh_subsurface(BlenderRNA *, StructRNA *srna)
static void def_sh_tex_ies(BlenderRNA *, StructRNA *srna)
static void def_geo_repeat_input(BlenderRNA *brna, StructRNA *srna)
static void rna_def_shader_node(BlenderRNA *brna)
@ SHD_WAVE_PROFILE_SAW
@ SHD_WAVE_PROFILE_TRI
@ SHD_WAVE_PROFILE_SIN
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
static void rna_def_cmp_file_output_item(BlenderRNA *brna)
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
VecBase< float, 2 > float2
static const EnumPropertyItem node_ycc_items[]
static void rna_def_geo_foreach_geometry_element_main_items(BlenderRNA *brna)
static void rna_def_geo_viewer(BlenderRNA *brna, StructRNA *srna)
static void def_geo_curve_sample(BlenderRNA *, StructRNA *srna)
static void def_geo_simulation_output(BlenderRNA *brna, StructRNA *srna)
static void def_sh_ambient_occlusion(BlenderRNA *, StructRNA *srna)
@ PROP_BOOLEAN
Definition RNA_types.hh:210
@ PROP_POINTER
Definition RNA_types.hh:215
@ PROP_STRING
Definition RNA_types.hh:213
@ PROP_COLLECTION
Definition RNA_types.hh:216
const EnumPropertyItem rna_enum_node_grease_pencil_merge_mode_items[]
static void def_closure_input(BlenderRNA *brna, StructRNA *srna)
@ SHD_MIXRGB_USE_ALPHA
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
static void rna_def_geo_menu_switch_items(BlenderRNA *brna)
static void def_separate_bundle(BlenderRNA *brna, StructRNA *srna)
void RNA_enum_items_add(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item)
RenderPass * BKE_image_multilayer_index(RenderResult *rr, ImageUser *iuser)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *assignint)
static const EnumPropertyItem sh_tex_prop_interpolation_items[]
bke::bNodeTreeType * rna_node_tree_type_from_enum(int value)
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
static void def_mix_rgb(BlenderRNA *, StructRNA *srna)
static void def_cmp_defocus(BlenderRNA *, StructRNA *srna)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
static void rna_def_geo_foreach_geometry_element_input_item(BlenderRNA *brna)
static void rna_def_geo_field_to_grid_item(BlenderRNA *brna)
static void def_refraction(BlenderRNA *, StructRNA *srna)
BMesh const char void * data
static void rna_def_geo_menu_switch_item(BlenderRNA *brna)
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:339
void RNA_def_property_override_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
static void def_cmp_combsep_color(BlenderRNA *, StructRNA *srna)
int IMB_colormanagement_colorspace_get_interop_id_index(const char *name, const char *interop_id)
static void rna_def_geo_closure_to_list_items(BlenderRNA *brna)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
const EnumPropertyItem rna_enum_attribute_domain_with_auto_items[]
static void rna_def_closure_input_items(BlenderRNA *brna)
const EnumPropertyItem rna_enum_node_vec_math_items[]
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static void rna_def_geo_field_to_list_items(BlenderRNA *brna)
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
static void def_hair(BlenderRNA *, StructRNA *srna)
static void def_sh_vector_rotate(BlenderRNA *, StructRNA *srna)
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
@ NODE_COMBINE_BUNDLE_FLAG_DEFINE_SIGNATURE
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
@ SHD_WAVE_RINGS_DIRECTION_SPHERICAL
@ SHD_WAVE_RINGS_DIRECTION_X
@ SHD_WAVE_RINGS_DIRECTION_Y
@ SHD_WAVE_RINGS_DIRECTION_Z
static void rna_def_fn_format_string_item(BlenderRNA *brna)
static void rna_def_geo_field_to_grid_items(BlenderRNA *brna)
void BKE_main_ensure_invariants(Main &bmain, std::optional< Span< ID * > > modified_ids=std::nullopt)
static const EnumPropertyItem node_toon_items[]
const EnumPropertyItem rna_enum_geometry_nodes_linear_gizmo_draw_style_items[]
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
const EnumPropertyItem rna_enum_node_integer_math_items[]
const EnumPropertyItem rna_enum_node_clamp_items[]
static void def_custom_group(BlenderRNA *brna, const char *struct_name, const char *base_name, const char *ui_name, const char *ui_desc, const char *reg_func)
bool BKE_main_view_layers_synced_ensure(const Main *bmain)
static void def_sh_bevel(BlenderRNA *, StructRNA *srna)
static void def_sh_displacement(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem prop_image_view_items[]
const EnumPropertyItem rna_enum_attribute_type_items[]
const EnumPropertyItem rna_enum_node_color_tag_items[]
void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
int rna_node_socket_idname_to_enum(const char *idname)
@ SHD_PROJ_MIRROR_BALL
@ SHD_PROJ_EQUIRECTANGULAR
static EnumPropertyItem node_ies_mode_items[]
bool void BLI_path_rel(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1)
static void rna_def_geometry_node(BlenderRNA *brna)
@ NODE_SCRIPT_EXTERNAL
@ NODE_SCRIPT_INTERNAL
const EnumPropertyItem rna_enum_node_boolean_math_items[]
static void def_float_to_int(BlenderRNA *, StructRNA *srna)
static void def_glass(BlenderRNA *, StructRNA *srna)
static void def_geo_foreach_geometry_element_output(BlenderRNA *brna, StructRNA *srna)
@ CMP_NODE_EXTENSION_MODE_REPEAT
@ CMP_NODE_EXTENSION_MODE_EXTEND
@ CMP_NODE_EXTENSION_MODE_CLIP
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
static void def_geo_input_normal(BlenderRNA *, StructRNA *srna)
@ NODE_VECTOR_ROTATE_TYPE_AXIS_Y
@ NODE_VECTOR_ROTATE_TYPE_EULER_XYZ
@ NODE_VECTOR_ROTATE_TYPE_AXIS_Z
@ NODE_VECTOR_ROTATE_TYPE_AXIS
@ NODE_VECTOR_ROTATE_TYPE_AXIS_X
SpaceNode * CTX_wm_space_node(const bContext *C)
@ NODE_COMPARE_COLOR_BRIGHTER
@ NODE_COMPARE_NOT_EQUAL
@ NODE_COMPARE_LESS_EQUAL
@ NODE_COMPARE_COLOR_DARKER
@ NODE_COMPARE_GREATER_EQUAL
@ NODE_COMPARE_GREATER_THAN
@ NODE_COMPARE_LESS_THAN
void register_node_type_geo_custom_group(bke::bNodeType *ntype)
static void def_sh_tex_wave(BlenderRNA *brna, StructRNA *srna)
static void def_light_evaluation(BlenderRNA *, StructRNA *srna)
static void def_glossy(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem * rna_enum_property_items_from_listbase(const ListBaseT< T > &listbase, CreateItemFn create_item_fn)
void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
const EnumPropertyItem rna_enum_color_space_convert_default_items[]
Definition rna_color.cc:25
const EnumPropertyItem rna_enum_node_socket_structure_type_items[]
static void def_math(BlenderRNA *, StructRNA *srna)
void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
void register_node_type_sh_custom_group(bke::bNodeType *ntype)
void rna_Node_socket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier_c_str, const char *call)
void BKE_ntree_update_tag_all(bNodeTree *ntree)
@ CMP_NODE_INTERPOLATION_NEAREST
@ CMP_NODE_INTERPOLATION_BICUBIC
@ CMP_NODE_INTERPOLATION_ANISOTROPIC
@ CMP_NODE_INTERPOLATION_BILINEAR
void rna_Node_update_relations(Main *bmain, Scene *scne, PointerRNA *ptr)
static void rna_def_closure_output_item(BlenderRNA *brna)
const EnumPropertyItem rna_enum_dummy_NULL_items[]
Definition rna_rna.cc:28
@ SHD_HAIR_REFLECTION
@ SHD_HAIR_TRANSMISSION
static void def_reroute(BlenderRNA *, StructRNA *srna)
static void rna_def_geo_viewer_items(BlenderRNA *brna)
void ntreeCompositCryptomatteSyncFromRemove(bNode *node)
void(*)(void *data) StructFreeFunc
void RNA_def_struct_register_funcs(StructRNA *srna, const char *reg, const char *unreg, const char *instance)
int BLI_listbase_count_at_most(const ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:518
static void def_sh_tex_checker(BlenderRNA *brna, StructRNA *srna)
static void def_sh_vect_transform(BlenderRNA *, StructRNA *srna)
void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:378
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static void def_comment(BlenderRNA *, StructRNA *srna)
@ SHD_VORONOI_EUCLIDEAN
@ SHD_VORONOI_MANHATTAN
@ SHD_VORONOI_CHEBYCHEV
@ SHD_VORONOI_MINKOWSKI
@ NODE_SCRIPT_AUTO_UPDATE
static void def_sh_tex_brick(BlenderRNA *brna, StructRNA *srna)
RenderEngineType * RE_engines_find(const char *idname)
void DEG_id_tag_update_for_side_effect_request(Depsgraph *depsgraph, ID *id, unsigned int flags)
@ GEO_NODE_GIZMO_COLOR_PRIMARY
@ GEO_NODE_GIZMO_COLOR_Y
@ GEO_NODE_GIZMO_COLOR_SECONDARY
@ GEO_NODE_GIZMO_COLOR_Z
@ GEO_NODE_GIZMO_COLOR_X
int RNA_struct_ui_icon(const StructRNA *type)
@ SHD_SPACE_BLENDER_WORLD
@ SHD_SPACE_BLENDER_OBJECT
void RNA_def_property_boolean_default(PropertyRNA *prop, bool value)
static void def_cmp_moviedistortion(BlenderRNA *, StructRNA *srna)
static void def_sh_tex_environment(BlenderRNA *brna, StructRNA *srna)
static void def_sh_tex_noise(BlenderRNA *brna, StructRNA *srna)
static void def_cmp_keyingscreen(BlenderRNA *, StructRNA *srna)
void RNA_parameter_get_lookup(ParameterList *parms, const char *identifier, void **r_value)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
static void def_geo_menu_switch(BlenderRNA *brna, StructRNA *srna)
static void def_sh_tex_voronoi(BlenderRNA *brna, StructRNA *srna)
bool IMB_colormanagement_set_whitepoint(const float whitepoint[3], float &temperature, float &tint)
static void def_cmp_cryptomatte(BlenderRNA *brna, StructRNA *srna)
void RNA_def_struct_idprops_func(StructRNA *srna, const char *idproperties)
static void rna_def_combine_bundle_item(BlenderRNA *brna)
static void def_cmp_huecorrect(BlenderRNA *, StructRNA *srna)
@ SHD_VECT_TRANSFORM_SPACE_WORLD
@ SHD_VECT_TRANSFORM_SPACE_CAMERA
@ SHD_VECT_TRANSFORM_SPACE_OBJECT
@ SHD_VECT_TRANSFORM_SPACE_LIGHT
static void rna_def_geo_foreach_geometry_element_generation_item(BlenderRNA *brna)
static void rna_def_geo_closure_to_list_item(BlenderRNA *brna)
static const EnumPropertyItem node_metallic_fresnel_type_items[]
const char * RNA_struct_ui_description(const StructRNA *type)
void ntreeTexCheckCyclics(struct bNodeTree *ntree)
static void def_group_input(BlenderRNA *, StructRNA *)
static void rna_def_geo_simulation_state_item(BlenderRNA *brna)
void RNA_def_function_flag(FunctionRNA *func, FunctionFlag flag)
static const EnumPropertyItem node_light_evaluation_mode_items[]
static void def_cmp_movieclip(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem prop_image_extension[]
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
const EnumPropertyItem rna_enum_node_geometry_mesh_circle_fill_type_items[]
static void def_geo_sample_index(BlenderRNA *, StructRNA *srna)
static void rna_def_closure_output_items(BlenderRNA *brna)
static void rna_def_evaluate_closure_output_items(BlenderRNA *brna)
RenderEngine * RE_engine_create(RenderEngineType *type)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
static StructRNA * define_specific_node(BlenderRNA *brna, const char *struct_name, const char *base_name)
static void def_sh_tex_gabor(BlenderRNA *brna, StructRNA *srna)
static void rna_def_texture_node(BlenderRNA *brna)
void RNA_struct_blender_type_set(StructRNA *srna, void *blender_type)
void BKE_ntree_update_tag_node_property(bNodeTree *ntree, bNode *node)
Main * CTX_data_main(const bContext *C)
FunctionRNA * RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
static void def_group_output(BlenderRNA *, StructRNA *srna)
void RNA_def_struct_translation_context(StructRNA *srna, const char *context)
static void def_fn_input_color(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem prop_image_layer_items[]
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
static void rna_def_node_item_array_new_with_socket_and_name(StructRNA *srna, const char *item_name, const char *accessor_name)
@ NODE_MIX_MODE_NON_UNIFORM
@ NODE_MIX_MODE_UNIFORM
@ SHD_SUBSURFACE_RANDOM_WALK_SKIN
@ SHD_SUBSURFACE_RANDOM_WALK
@ SHD_SUBSURFACE_BURLEY
@ SHD_SUBSURFACE_RANDOM_WALK_LEGACY
static void rna_def_compositor_node(BlenderRNA *brna)
char * BKE_cryptomatte_entries_to_matte_id(struct NodeCryptomatte *node_storage)
static void rna_def_geo_repeat_items(BlenderRNA *brna)
static void rna_def_sh_raycast_sample_attribute_item(BlenderRNA *brna)
@ NODE_VIEWER_SHORTCUT_NONE
static const EnumPropertyItem rna_enum_shader_vect_transform_space_items[]
static void def_closure_output(BlenderRNA *brna, StructRNA *srna)
static void def_fn_input_menu(BlenderRNA *, StructRNA *srna)
static void def_vector_math(BlenderRNA *, StructRNA *srna)
void BLF_cache_clear()
Definition blf.cc:100
bke::bNodeSocketType * rna_node_socket_type_from_enum(int value)
static void rna_def_geo_viewer_item(BlenderRNA *brna)
static void def_fn_input_string(BlenderRNA *, StructRNA *srna)
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
static void def_geo_set_grease_pencil_color(BlenderRNA *, StructRNA *srna)
void BKE_ntree_update_tag_active_output_changed(bNodeTree *ntree)
static void rna_def_geo_bake_item(BlenderRNA *brna)
@ ID_RECALC_NTREE_OUTPUT
Definition DNA_ID.h:1155
@ PROP_TEXTEDIT_UPDATE
Definition RNA_types.hh:396
@ PROP_EDITABLE
Definition RNA_types.hh:376
@ PROP_ENUM_NO_CONTEXT
Definition RNA_types.hh:500
@ PROP_ENUM_FLAG
Definition RNA_types.hh:474
@ PROP_PATH_OUTPUT
Definition RNA_types.hh:521
@ PROP_PATH_SUPPORTS_TEMPLATES
Definition RNA_types.hh:540
@ PROP_DYNAMIC
Definition RNA_types.hh:498
@ PROP_THICK_WRAP
Definition RNA_types.hh:493
@ PROP_PTR_NO_OWNERSHIP
Definition RNA_types.hh:465
@ PROP_REGISTER_OPTIONAL
Definition RNA_types.hh:482
@ PROP_REGISTER
Definition RNA_types.hh:481
@ PROP_ENUM_NO_TRANSLATE
Definition RNA_types.hh:502
@ PROP_PATH_SUPPORTS_BLEND_RELATIVE
Definition RNA_types.hh:526
@ PROP_NEVER_UNLINK
Definition RNA_types.hh:454
@ PROP_ID_REFCOUNT
Definition RNA_types.hh:434
@ PROP_NEVER_NULL
Definition RNA_types.hh:447
@ PROP_ANIMATABLE
Definition RNA_types.hh:389
@ PROP_NO_DEG_UPDATE
Definition RNA_types.hh:509
static void rna_def_node_panel_state(BlenderRNA *brna)
static void rna_def_texture_nodetree(BlenderRNA *brna)
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static void rna_def_geo_gizmo_transform(BlenderRNA *, StructRNA *srna)
@ NTREE_VIEWER_BORDER
static void def_geo_curve_handle_type_selection(BlenderRNA *, StructRNA *srna)
@ SHD_SKY_SINGLE_SCATTERING
@ SHD_SKY_MULTIPLE_SCATTERING
void ntreeCompositCryptomatteSyncFromAdd(bNode *node)
void IMB_colormanagement_colorspace_name_set(char *name, char *interop_id, const char *new_name)
const EnumPropertyItem rna_enum_node_math_items[]
static void def_geo_repeat_output(BlenderRNA *brna, StructRNA *srna)
void RNA_parameter_set_lookup(ParameterList *parms, const char *identifier, const void *value)
static void def_cmp_planetrackdeform(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem * rna_node_tree_type_itemf(void *data, bool(*poll)(void *data, bke::bNodeTreeType *), bool *r_free)
void RNA_def_nodetree(BlenderRNA *brna)
static void def_texture(BlenderRNA *, StructRNA *srna)
@ SHD_BLEND_QUADRATIC
@ SHD_BLEND_QUADRATIC_SPHERE
@ SHD_BLEND_SPHERICAL
PointerRNA RNA_pointer_create_id_subdata(ID &id, StructRNA *type, void *data)
static void def_geo_input_material(BlenderRNA *, StructRNA *srna)
static const EnumPropertyItem node_refraction_items[]
static void def_geo_merge_layers(BlenderRNA *, StructRNA *srna)
static void rna_def_geo_foreach_geometry_element_main_item(BlenderRNA *brna)
@ GEO_NODE_RASTERIZE_POINTS_ITEM_TYPE_SCALAR
@ GEO_NODE_RASTERIZE_POINTS_ITEM_TYPE_VECTOR
static void rna_def_geo_foreach_geometry_element_input_items(BlenderRNA *brna)
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
static void def_sheen(BlenderRNA *, StructRNA *srna)
PointerRNA RNA_pointer_create_with_parent(const PointerRNA &parent, StructRNA *type, void *data)
@ NODE_VECTOR_MATH_COSINE
@ NODE_VECTOR_MATH_SINE
@ NODE_VECTOR_MATH_MAXIMUM
@ NODE_VECTOR_MATH_FLOOR
@ NODE_VECTOR_MATH_MINIMUM
@ NODE_VECTOR_MATH_MULTIPLY_ADD
@ NODE_VECTOR_MATH_REFLECT
@ NODE_VECTOR_MATH_ROUND
@ NODE_VECTOR_MATH_TANGENT
@ NODE_VECTOR_MATH_PROJECT
@ NODE_VECTOR_MATH_SCALE
@ NODE_VECTOR_MATH_POWER
@ NODE_VECTOR_MATH_CROSS_PRODUCT
@ NODE_VECTOR_MATH_DIVIDE
@ NODE_VECTOR_MATH_NORMALIZE
@ NODE_VECTOR_MATH_SUBTRACT
@ NODE_VECTOR_MATH_DOT_PRODUCT
@ NODE_VECTOR_MATH_SNAP
@ NODE_VECTOR_MATH_DISTANCE
@ NODE_VECTOR_MATH_LENGTH
@ NODE_VECTOR_MATH_ADD
@ NODE_VECTOR_MATH_MODULO
@ NODE_VECTOR_MATH_FRACTION
@ NODE_VECTOR_MATH_CEIL
@ NODE_VECTOR_MATH_SIGN
@ NODE_VECTOR_MATH_WRAP
@ NODE_VECTOR_MATH_FACEFORWARD
@ NODE_VECTOR_MATH_REFRACT
@ NODE_VECTOR_MATH_MULTIPLY
@ NODE_VECTOR_MATH_ABSOLUTE
void DEG_relations_tag_update(Main *bmain)
static void rna_def_node_item_array_common_functions(StructRNA *srna, const char *item_name, const char *accessor_name)
const EnumPropertyItem rna_enum_node_socket_in_out_items[]
@ GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN
@ GEO_NODE_MESH_CIRCLE_FILL_NONE
@ GEO_NODE_MESH_CIRCLE_FILL_NGON
@ GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_CROSS
@ GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_BOX
@ GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_ARROW
static const EnumPropertyItem prop_shader_output_target_items[]
static void rna_def_geo_simulation_state_items(BlenderRNA *brna)
Scene * CTX_data_scene(const bContext *C)
@ GEO_NODE_BAKE_ITEM_IS_ATTRIBUTE
const EnumPropertyItem rna_enum_node_socket_data_type_items[]
void IMB_colormanagement_get_whitepoint(float temperature, float tint, float whitepoint[3])
@ SHD_VORONOI_SMOOTH_F1
@ SHD_VORONOI_DISTANCE_TO_EDGE
@ SHD_VORONOI_N_SPHERE_RADIUS
static void def_sh_tex_wireframe(BlenderRNA *, StructRNA *srna)
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
static const EnumPropertyItem rna_enum_node_tex_dimensions_items[]
static void rna_def_evaluate_closure_input_item(BlenderRNA *brna)
static void def_vector_curve(BlenderRNA *, StructRNA *srna)
static void def_fn_input_vector(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_node_combsep_color_items[]
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
static void def_cmp_trackpos(BlenderRNA *, StructRNA *srna)
static void def_common_zone_input(BlenderRNA *, StructRNA *srna)
@ PROP_XYZ_LENGTH
Definition RNA_types.hh:327
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_TRANSLATION
Definition RNA_types.hh:318
@ PROP_DISTANCE
Definition RNA_types.hh:313
@ PROP_FILEPATH
Definition RNA_types.hh:284
@ PROP_DIRPATH
Definition RNA_types.hh:285
@ PROP_DIRECTION
Definition RNA_types.hh:319
@ PROP_COLOR_GAMMA
Definition RNA_types.hh:329
@ PROP_UNSIGNED
Definition RNA_types.hh:306
@ PARM_REQUIRED
Definition RNA_types.hh:631
@ PARM_RNAPTR
Definition RNA_types.hh:633
static const EnumPropertyItem node_principled_hair_parametrization_items[]
const EnumPropertyItem rna_enum_node_geometry_curve_handle_side_items[]
@ CMP_NODE_CRYPTOMATTE_SOURCE_IMAGE
@ CMP_NODE_CRYPTOMATTE_SOURCE_RENDER
static void rna_def_sh_raycast_sample_attribute_items(BlenderRNA *brna)
const EnumPropertyItem rna_enum_icon_items[]
Definition rna_ui_api.cc:30
static void def_cmp_convert_to_display(BlenderRNA *, StructRNA *srna)
static void def_cmp_convert_color_space(BlenderRNA *, StructRNA *srna)
@ SHD_GLOSSY_ASHIKHMIN_SHIRLEY
@ SHD_GLOSSY_BECKMANN
@ SHD_GLOSSY_MULTI_GGX
static void def_cmp_file_output(BlenderRNA *brna, StructRNA *srna)
void RNA_def_property_int_default(PropertyRNA *prop, int value)
void RNA_struct_free_extension(StructRNA *srna, ExtensionRNA *rna_ext)
static void def_implicit_conversion(BlenderRNA *, StructRNA *srna)
void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop, const bool allow_replace)
void ED_init_custom_node_type(bke::bNodeType *ntype)
Definition drawnode.cc:1010
@ SHD_LIGHT_EVAL_GLOSSY
@ SHD_LIGHT_EVAL_DIFFUSE
@ NODE_PANEL_COLLAPSED
static void rna_def_index_switch_item(BlenderRNA *brna)
static void rna_def_combine_list_item(BlenderRNA *brna)
const EnumPropertyItem rna_enum_node_compositor_interpolation_items[]
static void def_geo_input_collection(BlenderRNA *, StructRNA *srna)
static void def_node_image_user(BlenderRNA *, StructRNA *srna)
static void def_geo_combine_list(BlenderRNA *brna, StructRNA *srna)
static void def_scatter(BlenderRNA *, StructRNA *srna)
void id_us_min(ID *id)
Definition lib_id.cc:441
static void def_geo_simulation_input(BlenderRNA *brna, StructRNA *srna)
static const EnumPropertyItem node_scatter_phase_items[]
@ GEO_NODE_MERGE_LAYERS_BY_ID
@ GEO_NODE_MERGE_LAYERS_BY_NAME
static void def_geo_image(BlenderRNA *, StructRNA *srna)
static void rna_def_rasterize_points_item(BlenderRNA *brna)
void RNA_def_property_array(PropertyRNA *prop, int length)
static void def_sh_tex_sky(BlenderRNA *brna, StructRNA *srna)
@ FN_NODE_ROTATE_EULER_TYPE_EULER
@ FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE
static void def_sh_tex_image(BlenderRNA *brna, StructRNA *srna)
const EnumPropertyItem rna_enum_node_map_range_items[]
static const EnumPropertyItem node_glass_items[]
static void def_float_curve(BlenderRNA *, StructRNA *srna)
void rna_iterator_array_begin(CollectionPropertyIterator *iter, PointerRNA *ptr, void *data, size_t itemsize, int64_t length, bool free_ptr, IteratorSkipFunc skip)
static const EnumPropertyItem node_principled_hair_model_items[]
int(*)(bContext *C, PointerRNA *ptr, FunctionRNA *func, ParameterList *list) StructCallbackFunc
static void rna_def_geo_capture_attribute(BlenderRNA *brna, StructRNA *srna)
static void def_cmp_colorbalance(BlenderRNA *, StructRNA *srna)
const EnumPropertyItem rna_enum_attribute_domain_items[]
static void def_cmp_cryptomatte_legacy(BlenderRNA *brna, StructRNA *srna)
void register_node_type_cmp_custom_group(bke::bNodeType *ntype)
static void def_sh_uvmap(BlenderRNA *, StructRNA *srna)
static void rna_def_geo_bake_items(BlenderRNA *brna)
static const EnumPropertyItem node_sheen_items[]
@ GEO_NODE_CURVE_SAMPLE_LENGTH
@ GEO_NODE_CURVE_SAMPLE_FACTOR
static void def_sh_raycast(BlenderRNA *brna, StructRNA *srna)
void RNA_parameter_list_free(ParameterList *parms)
static void rna_def_cmp_file_output_items(BlenderRNA *brna)
static void def_sh_tex_gradient(BlenderRNA *brna, StructRNA *srna)
BlenderRNA RNA_blender_rna_get()
static void rna_def_separate_bundle_items(BlenderRNA *brna)
static void def_tex_bricks(BlenderRNA *, StructRNA *srna)
static void rna_def_geo_repeat_item(BlenderRNA *brna)
static void def_sh_output_linestyle(BlenderRNA *brna, StructRNA *srna)
static void def_geo_input_font(BlenderRNA *, StructRNA *srna)
std::optional< std::string > rna_Node_ImageUser_path(const PointerRNA *ptr)
void BKE_cryptomatte_matte_id_to_entries(struct NodeCryptomatte *node_storage, const char *matte_id)
static void def_tex_image(BlenderRNA *, StructRNA *srna)
static void rna_def_evaluate_closure_output_item(BlenderRNA *brna)
void rna_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
@ GEO_NODE_CURVE_HANDLE_LEFT
@ GEO_NODE_CURVE_HANDLE_RIGHT
static void def_cmp_mask(BlenderRNA *, StructRNA *srna)
@ NODE_SEPARATE_BUNDLE_FLAG_DEFINE_SIGNATURE
StructRNA * RNA_def_struct_ptr(BlenderRNA *brna, const char *identifier, StructRNA *srnafrom)
#define min(a, b)
Definition sort.cc:38
eSpaceNode_ShaderFrom shaderfrom
struct CompositorNodeAssetTraits * compositor_node_asset_traits
struct GeometryNodeAssetTraits * geometry_node_asset_traits
bke::bNodeTreeRuntime * runtime
bke::bNodeType * typeinfo
IDProperty * system_properties
struct bNode * next
IDProperty * prop
static constexpr int GroupMin
Definition BKE_node.hh:256
static constexpr int Default
Definition BKE_node.hh:253
static constexpr int DefaultMax
Definition BKE_node.hh:254
Compact definition of a node socket.
Definition BKE_node.hh:102
Defines a socket type.
Definition BKE_node.hh:163
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
float x
float y
#define N_(msgid)