6cb893d165782ab4fd81da18a4991246cecaa2a2
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <limits.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "BLI_math.h"
26 #include "BLI_utildefines.h"
27
28 #include "BLT_translation.h"
29
30 #include "DNA_material_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_modifier_types.h"
33 #include "DNA_node_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_particle_types.h"
36 #include "DNA_text_types.h"
37 #include "DNA_texture_types.h"
38
39 #include "BKE_animsys.h"
40 #include "BKE_attribute.h"
41 #include "BKE_cryptomatte.h"
42 #include "BKE_image.h"
43 #include "BKE_node.h"
44 #include "BKE_texture.h"
45
46 #include "RNA_access.h"
47 #include "RNA_define.h"
48 #include "RNA_enum_types.h"
49
50 #include "rna_internal.h"
51 #include "rna_internal_types.h"
52
53 #include "IMB_imbuf.h"
54 #include "IMB_imbuf_types.h"
55
56 #include "WM_types.h"
57
58 #include "MEM_guardedalloc.h"
59
60 #include "RE_texture.h"
61
62 #include "DEG_depsgraph.h"
63 #include "DEG_depsgraph_query.h"
64
65 const EnumPropertyItem rna_enum_node_socket_in_out_items[] = {
66     {SOCK_IN, "IN", 0, "Input", ""}, {SOCK_OUT, "OUT", 0, "Output", ""}, {0, NULL, 0, NULL, NULL}};
67
68 static const EnumPropertyItem node_socket_data_type_items[] = {
69     {SOCK_FLOAT, "FLOAT", 0, "Float", ""},
70     {SOCK_INT, "INT", 0, "Integer", ""},
71     {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
72     {SOCK_VECTOR, "VECTOR", 0, "Vector", ""},
73     {SOCK_STRING, "STRING", 0, "String", ""},
74     {SOCK_RGBA, "RGBA", 0, "Color", ""},
75     {SOCK_OBJECT, "OBJECT", 0, "Object", ""},
76     {SOCK_IMAGE, "IMAGE", 0, "Image", ""},
77     {SOCK_GEOMETRY, "GEOMETRY", 0, "Geometry", ""},
78     {SOCK_COLLECTION, "COLLECTION", 0, "Collection", ""},
79     {SOCK_TEXTURE, "TEXTURE", 0, "Texture", ""},
80     {SOCK_MATERIAL, "MATERIAL", 0, "Material", ""},
81     {0, NULL, 0, NULL, NULL},
82 };
83
84 #ifndef RNA_RUNTIME
85 static const EnumPropertyItem rna_enum_node_socket_display_shape_items[] = {
86     {SOCK_DISPLAY_SHAPE_CIRCLE, "CIRCLE", 0, "Circle", ""},
87     {SOCK_DISPLAY_SHAPE_SQUARE, "SQUARE", 0, "Square", ""},
88     {SOCK_DISPLAY_SHAPE_DIAMOND, "DIAMOND", 0, "Diamond", ""},
89     {SOCK_DISPLAY_SHAPE_CIRCLE_DOT, "CIRCLE_DOT", 0, "Circle with inner dot", ""},
90     {SOCK_DISPLAY_SHAPE_SQUARE_DOT, "SQUARE_DOT", 0, "Square with inner dot", ""},
91     {SOCK_DISPLAY_SHAPE_DIAMOND_DOT, "DIAMOND_DOT", 0, "Diamond with inner dot", ""},
92     {0, NULL, 0, NULL, NULL}};
93
94 static const EnumPropertyItem node_socket_type_items[] = {
95     {SOCK_CUSTOM, "CUSTOM", 0, "Custom", ""},
96     {SOCK_FLOAT, "VALUE", 0, "Value", ""},
97     {SOCK_INT, "INT", 0, "Integer", ""},
98     {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
99     {SOCK_VECTOR, "VECTOR", 0, "Vector", ""},
100     {SOCK_STRING, "STRING", 0, "String", ""},
101     {SOCK_RGBA, "RGBA", 0, "RGBA", ""},
102     {SOCK_SHADER, "SHADER", 0, "Shader", ""},
103     {SOCK_OBJECT, "OBJECT", 0, "Object", ""},
104     {SOCK_IMAGE, "IMAGE", 0, "Image", ""},
105     {SOCK_GEOMETRY, "GEOMETRY", 0, "Geometry", ""},
106     {SOCK_COLLECTION, "COLLECTION", 0, "Collection", ""},
107     {SOCK_TEXTURE, "TEXTURE", 0, "Texture", ""},
108     {SOCK_MATERIAL, "MATERIAL", 0, "Material", ""},
109     {0, NULL, 0, NULL, NULL},
110 };
111
112 static const EnumPropertyItem node_quality_items[] = {
113     {NTREE_QUALITY_HIGH, "HIGH", 0, "High", "High quality"},
114     {NTREE_QUALITY_MEDIUM, "MEDIUM", 0, "Medium", "Medium quality"},
115     {NTREE_QUALITY_LOW, "LOW", 0, "Low", "Low quality"},
116     {0, NULL, 0, NULL, NULL},
117 };
118
119 static const EnumPropertyItem node_chunksize_items[] = {
120     {NTREE_CHUNKSIZE_32, "32", 0, "32x32", "Chunksize of 32x32"},
121     {NTREE_CHUNKSIZE_64, "64", 0, "64x64", "Chunksize of 64x64"},
122     {NTREE_CHUNKSIZE_128, "128", 0, "128x128", "Chunksize of 128x128"},
123     {NTREE_CHUNKSIZE_256, "256", 0, "256x256", "Chunksize of 256x256"},
124     {NTREE_CHUNKSIZE_512, "512", 0, "512x512", "Chunksize of 512x512"},
125     {NTREE_CHUNKSIZE_1024, "1024", 0, "1024x1024", "Chunksize of 1024x1024"},
126     {0, NULL, 0, NULL, NULL},
127 };
128 #endif
129
130 const EnumPropertyItem rna_enum_mapping_type_items[] = {
131     {NODE_MAPPING_TYPE_POINT, "POINT", 0, "Point", "Transform a point"},
132     {NODE_MAPPING_TYPE_TEXTURE,
133      "TEXTURE",
134      0,
135      "Texture",
136      "Transform a texture by inverse mapping the texture coordinate"},
137     {NODE_MAPPING_TYPE_VECTOR,
138      "VECTOR",
139      0,
140      "Vector",
141      "Transform a direction vector. Location is ignored"},
142     {NODE_MAPPING_TYPE_NORMAL,
143      "NORMAL",
144      0,
145      "Normal",
146      "Transform a unit normal vector. Location is ignored"},
147     {0, NULL, 0, NULL, NULL},
148 };
149
150 static const EnumPropertyItem rna_enum_vector_rotate_type_items[] = {
151     {NODE_VECTOR_ROTATE_TYPE_AXIS,
152      "AXIS_ANGLE",
153      0,
154      "Axis Angle",
155      "Rotate a point using axis angle"},
156     {NODE_VECTOR_ROTATE_TYPE_AXIS_X, "X_AXIS", 0, "X Axis", "Rotate a point using X axis"},
157     {NODE_VECTOR_ROTATE_TYPE_AXIS_Y, "Y_AXIS", 0, "Y Axis", "Rotate a point using Y axis"},
158     {NODE_VECTOR_ROTATE_TYPE_AXIS_Z, "Z_AXIS", 0, "Z Axis", "Rotate a point using Z axis"},
159     {NODE_VECTOR_ROTATE_TYPE_EULER_XYZ, "EULER_XYZ", 0, "Euler", "Rotate a point using XYZ order"},
160     {0, NULL, 0, NULL, NULL},
161 };
162
163 const EnumPropertyItem rna_enum_node_math_items[] = {
164     {0, "", 0, N_("Functions"), ""},
165     {NODE_MATH_ADD, "ADD", 0, "Add", "A + B"},
166     {NODE_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", "A - B"},
167     {NODE_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", "A * B"},
168     {NODE_MATH_DIVIDE, "DIVIDE", 0, "Divide", "A / B"},
169     {NODE_MATH_MULTIPLY_ADD, "MULTIPLY_ADD", 0, "Multiply Add", "A * B + C"},
170     {0, "", ICON_NONE, NULL, NULL},
171     {NODE_MATH_POWER, "POWER", 0, "Power", "A power B"},
172     {NODE_MATH_LOGARITHM, "LOGARITHM", 0, "Logarithm", "Logarithm A base B"},
173     {NODE_MATH_SQRT, "SQRT", 0, "Square Root", "Square root of A"},
174     {NODE_MATH_INV_SQRT, "INVERSE_SQRT", 0, "Inverse Square Root", "1 / Square root of A"},
175     {NODE_MATH_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Magnitude of A"},
176     {NODE_MATH_EXPONENT, "EXPONENT", 0, "Exponent", "exp(A)"},
177     {0, "", 0, N_("Comparison"), ""},
178     {NODE_MATH_MINIMUM, "MINIMUM", 0, "Minimum", "The minimum from A and B"},
179     {NODE_MATH_MAXIMUM, "MAXIMUM", 0, "Maximum", "The maximum from A and B"},
180     {NODE_MATH_LESS_THAN, "LESS_THAN", 0, "Less Than", "1 if A < B else 0"},
181     {NODE_MATH_GREATER_THAN, "GREATER_THAN", 0, "Greater Than", "1 if A > B else 0"},
182     {NODE_MATH_SIGN, "SIGN", 0, "Sign", "Returns the sign of A"},
183     {NODE_MATH_COMPARE, "COMPARE", 0, "Compare", "1 if (A == B) within tolerance C else 0"},
184     {NODE_MATH_SMOOTH_MIN,
185      "SMOOTH_MIN",
186      0,
187      "Smooth Minimum",
188      "The minimum from A and B with smoothing C"},
189     {NODE_MATH_SMOOTH_MAX,
190      "SMOOTH_MAX",
191      0,
192      "Smooth Maximum",
193      "The maximum from A and B with smoothing C"},
194     {0, "", 0, N_("Rounding"), ""},
195     {NODE_MATH_ROUND,
196      "ROUND",
197      0,
198      "Round",
199      "Round A to the nearest integer. Round upward if the fraction part is 0.5"},
200     {NODE_MATH_FLOOR, "FLOOR", 0, "Floor", "The largest integer smaller than or equal A"},
201     {NODE_MATH_CEIL, "CEIL", 0, "Ceil", "The smallest integer greater than or equal A"},
202     {NODE_MATH_TRUNC, "TRUNC", 0, "Truncate", "The integer part of A, removing fractional digits"},
203     {0, "", ICON_NONE, NULL, NULL},
204     {NODE_MATH_FRACTION, "FRACT", 0, "Fraction", "The fraction part of A"},
205     {NODE_MATH_MODULO, "MODULO", 0, "Modulo", "Modulo using fmod(A,B)"},
206     {NODE_MATH_WRAP, "WRAP", 0, "Wrap", "Wrap value to range, wrap(A,B)"},
207     {NODE_MATH_SNAP, "SNAP", 0, "Snap", "Snap to increment, snap(A,B)"},
208     {NODE_MATH_PINGPONG,
209      "PINGPONG",
210      0,
211      "Ping-Pong",
212      "Wraps a value and reverses every other cycle (A,B)"},
213     {0, "", 0, N_("Trigonometric"), ""},
214     {NODE_MATH_SINE, "SINE", 0, "Sine", "sin(A)"},
215     {NODE_MATH_COSINE, "COSINE", 0, "Cosine", "cos(A)"},
216     {NODE_MATH_TANGENT, "TANGENT", 0, "Tangent", "tan(A)"},
217     {0, "", ICON_NONE, NULL, NULL},
218     {NODE_MATH_ARCSINE, "ARCSINE", 0, "Arcsine", "arcsin(A)"},
219     {NODE_MATH_ARCCOSINE, "ARCCOSINE", 0, "Arccosine", "arccos(A)"},
220     {NODE_MATH_ARCTANGENT, "ARCTANGENT", 0, "Arctangent", "arctan(A)"},
221     {NODE_MATH_ARCTAN2, "ARCTAN2", 0, "Arctan2", "The signed angle arctan(A / B)"},
222     {0, "", ICON_NONE, NULL, NULL},
223     {NODE_MATH_SINH, "SINH", 0, "Hyperbolic Sine", "sinh(A)"},
224     {NODE_MATH_COSH, "COSH", 0, "Hyperbolic Cosine", "cosh(A)"},
225     {NODE_MATH_TANH, "TANH", 0, "Hyperbolic Tangent", "tanh(A)"},
226     {0, "", 0, N_("Conversion"), ""},
227     {NODE_MATH_RADIANS, "RADIANS", 0, "To Radians", "Convert from degrees to radians"},
228     {NODE_MATH_DEGREES, "DEGREES", 0, "To Degrees", "Convert from radians to degrees"},
229     {0, NULL, 0, NULL, NULL},
230 };
231
232 const EnumPropertyItem rna_enum_node_vec_math_items[] = {
233     {NODE_VECTOR_MATH_ADD, "ADD", 0, "Add", "A + B"},
234     {NODE_VECTOR_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", "A - B"},
235     {NODE_VECTOR_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", "Entry-wise multiply"},
236     {NODE_VECTOR_MATH_DIVIDE, "DIVIDE", 0, "Divide", "Entry-wise divide"},
237     {0, "", ICON_NONE, NULL, NULL},
238     {NODE_VECTOR_MATH_CROSS_PRODUCT, "CROSS_PRODUCT", 0, "Cross Product", "A cross B"},
239     {NODE_VECTOR_MATH_PROJECT, "PROJECT", 0, "Project", "Project A onto B"},
240     {NODE_VECTOR_MATH_REFLECT,
241      "REFLECT",
242      0,
243      "Reflect",
244      "Reflect A around the normal B. B doesn't need to be normalized"},
245     {NODE_VECTOR_MATH_REFRACT,
246      "REFRACT",
247      0,
248      "Refract",
249      "For a given incident vector A, surface normal B and ratio of indices of refraction, Ior, "
250      "refract returns the refraction vector, R"},
251     {NODE_VECTOR_MATH_FACEFORWARD,
252      "FACEFORWARD",
253      0,
254      "Faceforward",
255      "Orients a vector A to point away from a surface B as defined by its normal C. "
256      "Returns (dot(B, C) < 0) ? A : -A"},
257     {NODE_VECTOR_MATH_DOT_PRODUCT, "DOT_PRODUCT", 0, "Dot Product", "A dot B"},
258     {0, "", ICON_NONE, NULL, NULL},
259     {NODE_VECTOR_MATH_DISTANCE, "DISTANCE", 0, "Distance", "Distance between A and B"},
260     {NODE_VECTOR_MATH_LENGTH, "LENGTH", 0, "Length", "Length of A"},
261     {NODE_VECTOR_MATH_SCALE, "SCALE", 0, "Scale", "A multiplied by Scale"},
262     {NODE_VECTOR_MATH_NORMALIZE, "NORMALIZE", 0, "Normalize", "Normalize A"},
263     {0, "", ICON_NONE, NULL, NULL},
264     {NODE_VECTOR_MATH_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Entry-wise absolute"},
265     {NODE_VECTOR_MATH_MINIMUM, "MINIMUM", 0, "Minimum", "Entry-wise minimum"},
266     {NODE_VECTOR_MATH_MAXIMUM, "MAXIMUM", 0, "Maximum", "Entry-wise maximum"},
267     {NODE_VECTOR_MATH_FLOOR, "FLOOR", 0, "Floor", "Entry-wise floor"},
268     {NODE_VECTOR_MATH_CEIL, "CEIL", 0, "Ceil", "Entry-wise ceil"},
269     {NODE_VECTOR_MATH_FRACTION, "FRACTION", 0, "Fraction", "The fraction part of A entry-wise"},
270     {NODE_VECTOR_MATH_MODULO, "MODULO", 0, "Modulo", "Entry-wise modulo using fmod(A,B)"},
271     {NODE_VECTOR_MATH_WRAP, "WRAP", 0, "Wrap", "Entry-wise wrap(A,B)"},
272     {NODE_VECTOR_MATH_SNAP,
273      "SNAP",
274      0,
275      "Snap",
276      "Round A to the largest integer multiple of B less than or equal A"},
277     {0, "", ICON_NONE, NULL, NULL},
278     {NODE_VECTOR_MATH_SINE, "SINE", 0, "Sine", "Entry-wise sin(A)"},
279     {NODE_VECTOR_MATH_COSINE, "COSINE", 0, "Cosine", "Entry-wise cos(A)"},
280     {NODE_VECTOR_MATH_TANGENT, "TANGENT", 0, "Tangent", "Entry-wise tan(A)"},
281     {0, NULL, 0, NULL, NULL},
282 };
283
284 const EnumPropertyItem rna_enum_node_boolean_math_items[] = {
285     {NODE_BOOLEAN_MATH_AND, "AND", 0, "And", "Outputs true only when both inputs are true"},
286     {NODE_BOOLEAN_MATH_OR, "OR", 0, "Or", "Outputs or when at least one of the inputs is true"},
287     {NODE_BOOLEAN_MATH_NOT, "NOT", 0, "Not", "Outputs the opposite of the input"},
288     {0, NULL, 0, NULL, NULL},
289 };
290
291 const EnumPropertyItem rna_enum_node_float_compare_items[] = {
292     {NODE_FLOAT_COMPARE_LESS_THAN,
293      "LESS_THAN",
294      0,
295      "Less Than",
296      "True when the first input is smaller than second input"},
297     {NODE_FLOAT_COMPARE_LESS_EQUAL,
298      "LESS_EQUAL",
299      0,
300      "Less Than or Equal",
301      "True when the first input is smaller than the second input or equal"},
302     {NODE_FLOAT_COMPARE_GREATER_THAN,
303      "GREATER_THAN",
304      0,
305      "Greater Than",
306      "True when the first input is greater than the second input"},
307     {NODE_FLOAT_COMPARE_GREATER_EQUAL,
308      "GREATER_EQUAL",
309      0,
310      "Greater Than or Equal",
311      "True when the first input is greater than the second input or equal"},
312     {NODE_FLOAT_COMPARE_EQUAL,
313      "EQUAL",
314      0,
315      "Equal",
316      "True when both inputs are approximately equal"},
317     {NODE_FLOAT_COMPARE_NOT_EQUAL,
318      "NOT_EQUAL",
319      0,
320      "Not Equal",
321      "True when both inputs are not approximately equal"},
322     {0, NULL, 0, NULL, NULL},
323 };
324
325 const EnumPropertyItem rna_enum_node_map_range_items[] = {
326     {NODE_MAP_RANGE_LINEAR,
327      "LINEAR",
328      0,
329      "Linear",
330      "Linear interpolation between From Min and From Max values"},
331     {NODE_MAP_RANGE_STEPPED,
332      "STEPPED",
333      0,
334      "Stepped Linear",
335      "Stepped linear interpolation between From Min and From Max values"},
336     {NODE_MAP_RANGE_SMOOTHSTEP,
337      "SMOOTHSTEP",
338      0,
339      "Smooth Step",
340      "Smooth Hermite edge interpolation between From Min and From Max values"},
341     {NODE_MAP_RANGE_SMOOTHERSTEP,
342      "SMOOTHERSTEP",
343      0,
344      "Smoother Step",
345      "Smoother Hermite edge interpolation between From Min and From Max values"},
346     {0, NULL, 0, NULL, NULL},
347 };
348
349 const EnumPropertyItem rna_enum_node_clamp_items[] = {
350     {NODE_CLAMP_MINMAX, "MINMAX", 0, "Min Max", "Constrain value between min and max"},
351     {NODE_CLAMP_RANGE,
352      "RANGE",
353      0,
354      "Range",
355      "Constrain value between min and max, swapping arguments when min > max"},
356     {0, NULL, 0, NULL, NULL},
357 };
358
359 static const EnumPropertyItem rna_enum_node_tex_dimensions_items[] = {
360     {1, "1D", 0, "1D", "Use the scalar value W as input"},
361     {2, "2D", 0, "2D", "Use the 2D vector (x, y) as input. The z component is ignored"},
362     {3, "3D", 0, "3D", "Use the 3D vector Vector as input"},
363     {4, "4D", 0, "4D", "Use the 4D vector (x, y, z, w) as input"},
364     {0, NULL, 0, NULL, NULL},
365 };
366
367 const EnumPropertyItem rna_enum_node_filter_items[] = {
368     {0, "SOFTEN", 0, "Soften", ""},
369     {1, "SHARPEN", 0, "Sharpen", ""},
370     {2, "LAPLACE", 0, "Laplace", ""},
371     {3, "SOBEL", 0, "Sobel", ""},
372     {4, "PREWITT", 0, "Prewitt", ""},
373     {5, "KIRSCH", 0, "Kirsch", ""},
374     {6, "SHADOW", 0, "Shadow", ""},
375     {0, NULL, 0, NULL, NULL},
376 };
377
378 static const EnumPropertyItem rna_node_geometry_attribute_randomize_operation_items[] = {
379     {GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE,
380      "REPLACE_CREATE",
381      ICON_NONE,
382      "Replace/Create",
383      "Replace the value and data type of an existing attribute, or create a new one"},
384     {GEO_NODE_ATTRIBUTE_RANDOMIZE_ADD,
385      "ADD",
386      ICON_NONE,
387      "Add",
388      "Add the random values to the existing attribute values"},
389     {GEO_NODE_ATTRIBUTE_RANDOMIZE_SUBTRACT,
390      "SUBTRACT",
391      ICON_NONE,
392      "Subtract",
393      "Subtract random values from the existing attribute values"},
394     {GEO_NODE_ATTRIBUTE_RANDOMIZE_MULTIPLY,
395      "MULTIPLY",
396      ICON_NONE,
397      "Multiply",
398      "Multiply the existing attribute values with the random values"},
399     {0, NULL, 0, NULL, NULL},
400 };
401
402 #ifndef RNA_RUNTIME
403 static const EnumPropertyItem node_sampler_type_items[] = {
404     {0, "NEAREST", 0, "Nearest", ""},
405     {1, "BILINEAR", 0, "Bilinear", ""},
406     {2, "BICUBIC", 0, "Bicubic", ""},
407     {0, NULL, 0, NULL, NULL},
408 };
409
410 static const EnumPropertyItem prop_shader_output_target_items[] = {
411     {SHD_OUTPUT_ALL,
412      "ALL",
413      0,
414      "All",
415      "Use shaders for all renderers and viewports, unless there exists a more specific output"},
416     {SHD_OUTPUT_EEVEE, "EEVEE", 0, "Eevee", "Use shaders for Eevee renderer"},
417     {SHD_OUTPUT_CYCLES, "CYCLES", 0, "Cycles", "Use shaders for Cycles renderer"},
418     {0, NULL, 0, NULL, NULL},
419 };
420
421 static const EnumPropertyItem node_cryptomatte_layer_name_items[] = {
422     {0, "CryptoObject", 0, "Object", "Use Object layer"},
423     {1, "CryptoMaterial", 0, "Material", "Use Material layer"},
424     {2, "CryptoAsset", 0, "Asset", "Use Asset layer"},
425     {0, NULL, 0, NULL, NULL},
426 };
427
428 static EnumPropertyItem rna_node_geometry_mesh_circle_fill_type_items[] = {
429     {GEO_NODE_MESH_CIRCLE_FILL_NONE, "NONE", 0, "None", ""},
430     {GEO_NODE_MESH_CIRCLE_FILL_NGON, "NGON", 0, "N-Gon", ""},
431     {GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN, "TRIANGLE_FAN", 0, "Triangles", ""},
432     {0, NULL, 0, NULL, NULL},
433 };
434 #endif
435
436 #define ITEM_ATTRIBUTE \
437   { \
438     GEO_NODE_ATTRIBUTE_INPUT_ATTRIBUTE, "ATTRIBUTE", 0, "Attribute", "" \
439   }
440 #define ITEM_FLOAT \
441   { \
442     GEO_NODE_ATTRIBUTE_INPUT_FLOAT, "FLOAT", 0, "Float", "" \
443   }
444 #define ITEM_VECTOR \
445   { \
446     GEO_NODE_ATTRIBUTE_INPUT_VECTOR, "VECTOR", 0, "Vector", "" \
447   }
448 #define ITEM_COLOR \
449   { \
450     GEO_NODE_ATTRIBUTE_INPUT_COLOR, "COLOR", 0, "Color", "" \
451   }
452 #define ITEM_BOOLEAN \
453   { \
454     GEO_NODE_ATTRIBUTE_INPUT_BOOLEAN, "BOOLEAN", 0, "Boolean", "" \
455   }
456
457 /* Used in both runtime and static code. */
458 static const EnumPropertyItem rna_node_geometry_attribute_input_type_items_any[] = {
459     ITEM_ATTRIBUTE,
460     ITEM_FLOAT,
461     ITEM_VECTOR,
462     ITEM_COLOR,
463     ITEM_BOOLEAN,
464     {0, NULL, 0, NULL, NULL},
465 };
466
467 #ifndef RNA_RUNTIME
468
469 static const EnumPropertyItem rna_node_geometry_attribute_input_type_items_vector[] = {
470     ITEM_ATTRIBUTE,
471     ITEM_VECTOR,
472     {0, NULL, 0, NULL, NULL},
473 };
474 static const EnumPropertyItem rna_node_geometry_attribute_input_type_items_float_vector[] = {
475     ITEM_ATTRIBUTE,
476     ITEM_FLOAT,
477     ITEM_VECTOR,
478     {0, NULL, 0, NULL, NULL},
479 };
480 static const EnumPropertyItem rna_node_geometry_attribute_input_type_items_float[] = {
481     ITEM_ATTRIBUTE,
482     ITEM_FLOAT,
483     {0, NULL, 0, NULL, NULL},
484 };
485 static const EnumPropertyItem rna_node_geometry_attribute_input_type_items_no_boolean[] = {
486     ITEM_ATTRIBUTE,
487     ITEM_FLOAT,
488     ITEM_VECTOR,
489     ITEM_COLOR,
490     {0, NULL, 0, NULL, NULL},
491 };
492
493 #endif
494
495 #undef ITEM_ATTRIBUTE
496 #undef ITEM_FLOAT
497 #undef ITEM_VECTOR
498 #undef ITEM_COLOR
499 #undef ITEM_BOOLEAN
500
501 #ifdef RNA_RUNTIME
502
503 #  include "BLI_linklist.h"
504 #  include "BLI_string.h"
505
506 #  include "BKE_context.h"
507 #  include "BKE_idprop.h"
508
509 #  include "BKE_global.h"
510
511 #  include "ED_node.h"
512 #  include "ED_render.h"
513
514 #  include "GPU_material.h"
515
516 #  include "NOD_common.h"
517 #  include "NOD_composite.h"
518 #  include "NOD_geometry.h"
519 #  include "NOD_shader.h"
520 #  include "NOD_socket.h"
521
522 #  include "RE_engine.h"
523 #  include "RE_pipeline.h"
524
525 #  include "DNA_scene_types.h"
526 #  include "WM_api.h"
527
528 static void rna_Node_socket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr);
529
530 int rna_node_tree_type_to_enum(bNodeTreeType *typeinfo)
531 {
532   int i = 0, result = -1;
533   NODE_TREE_TYPES_BEGIN (nt) {
534     if (nt == typeinfo) {
535       result = i;
536       break;
537     }
538     i++;
539   }
540   NODE_TREE_TYPES_END;
541   return result;
542 }
543
544 int rna_node_tree_idname_to_enum(const char *idname)
545 {
546   int i = 0, result = -1;
547   NODE_TREE_TYPES_BEGIN (nt) {
548     if (STREQ(nt->idname, idname)) {
549       result = i;
550       break;
551     }
552     i++;
553   }
554   NODE_TREE_TYPES_END;
555   return result;
556 }
557
558 bNodeTreeType *rna_node_tree_type_from_enum(int value)
559 {
560   int i = 0;
561   bNodeTreeType *result = NULL;
562   NODE_TREE_TYPES_BEGIN (nt) {
563     if (i == value) {
564       result = nt;
565       break;
566     }
567     i++;
568   }
569   NODE_TREE_TYPES_END;
570   return result;
571 }
572
573 const EnumPropertyItem *rna_node_tree_type_itemf(void *data,
574                                                  bool (*poll)(void *data, bNodeTreeType *),
575                                                  bool *r_free)
576 {
577   EnumPropertyItem tmp = {0};
578   EnumPropertyItem *item = NULL;
579   int totitem = 0, i = 0;
580
581   NODE_TREE_TYPES_BEGIN (nt) {
582     if (poll && !poll(data, nt)) {
583       i++;
584       continue;
585     }
586
587     tmp.value = i;
588     tmp.identifier = nt->idname;
589     tmp.icon = nt->ui_icon;
590     tmp.name = nt->ui_name;
591     tmp.description = nt->ui_description;
592
593     RNA_enum_item_add(&item, &totitem, &tmp);
594
595     i++;
596   }
597   NODE_TREE_TYPES_END;
598
599   if (totitem == 0) {
600     *r_free = false;
601     return DummyRNA_NULL_items;
602   }
603
604   RNA_enum_item_end(&item, &totitem);
605   *r_free = true;
606
607   return item;
608 }
609
610 int rna_node_type_to_enum(bNodeType *typeinfo)
611 {
612   int i = 0, result = -1;
613   NODE_TYPES_BEGIN (ntype) {
614     if (ntype == typeinfo) {
615       result = i;
616       break;
617     }
618     i++;
619   }
620   NODE_TYPES_END;
621   return result;
622 }
623
624 int rna_node_idname_to_enum(const char *idname)
625 {
626   int i = 0, result = -1;
627   NODE_TYPES_BEGIN (ntype) {
628     if (STREQ(ntype->idname, idname)) {
629       result = i;
630       break;
631     }
632     i++;
633   }
634   NODE_TYPES_END;
635   return result;
636 }
637
638 bNodeType *rna_node_type_from_enum(int value)
639 {
640   int i = 0;
641   bNodeType *result = NULL;
642   NODE_TYPES_BEGIN (ntype) {
643     if (i == value) {
644       result = ntype;
645       break;
646     }
647     i++;
648   }
649   NODE_TYPES_END;
650   return result;
651 }
652
653 const EnumPropertyItem *rna_node_type_itemf(void *data,
654                                             bool (*poll)(void *data, bNodeType *),
655                                             bool *r_free)
656 {
657   EnumPropertyItem *item = NULL;
658   EnumPropertyItem tmp = {0};
659   int totitem = 0, i = 0;
660
661   NODE_TYPES_BEGIN (ntype) {
662     if (poll && !poll(data, ntype)) {
663       i++;
664       continue;
665     }
666
667     tmp.value = i;
668     tmp.identifier = ntype->idname;
669     tmp.icon = ntype->ui_icon;
670     tmp.name = ntype->ui_name;
671     tmp.description = ntype->ui_description;
672
673     RNA_enum_item_add(&item, &totitem, &tmp);
674
675     i++;
676   }
677   NODE_TYPES_END;
678
679   if (totitem == 0) {
680     *r_free = false;
681     return DummyRNA_NULL_items;
682   }
683
684   RNA_enum_item_end(&item, &totitem);
685   *r_free = true;
686
687   return item;
688 }
689
690 int rna_node_socket_type_to_enum(bNodeSocketType *typeinfo)
691 {
692   int i = 0, result = -1;
693   NODE_SOCKET_TYPES_BEGIN (stype) {
694     if (stype == typeinfo) {
695       result = i;
696       break;
697     }
698     i++;
699   }
700   NODE_SOCKET_TYPES_END;
701   return result;
702 }
703
704 int rna_node_socket_idname_to_enum(const char *idname)
705 {
706   int i = 0, result = -1;
707   NODE_SOCKET_TYPES_BEGIN (stype) {
708     if (STREQ(stype->idname, idname)) {
709       result = i;
710       break;
711     }
712     i++;
713   }
714   NODE_SOCKET_TYPES_END;
715   return result;
716 }
717
718 bNodeSocketType *rna_node_socket_type_from_enum(int value)
719 {
720   int i = 0;
721   bNodeSocketType *result = NULL;
722   NODE_SOCKET_TYPES_BEGIN (stype) {
723     if (i == value) {
724       result = stype;
725       break;
726     }
727     i++;
728   }
729   NODE_SOCKET_TYPES_END;
730   return result;
731 }
732
733 const EnumPropertyItem *rna_node_socket_type_itemf(void *data,
734                                                    bool (*poll)(void *data, bNodeSocketType *),
735                                                    bool *r_free)
736 {
737   EnumPropertyItem *item = NULL;
738   EnumPropertyItem tmp = {0};
739   int totitem = 0, i = 0;
740   StructRNA *srna;
741
742   NODE_SOCKET_TYPES_BEGIN (stype) {
743     if (poll && !poll(data, stype)) {
744       i++;
745       continue;
746     }
747
748     srna = stype->ext_socket.srna;
749     tmp.value = i;
750     tmp.identifier = stype->idname;
751     tmp.icon = RNA_struct_ui_icon(srna);
752     tmp.name = RNA_struct_ui_name(srna);
753     tmp.description = RNA_struct_ui_description(srna);
754
755     RNA_enum_item_add(&item, &totitem, &tmp);
756
757     i++;
758   }
759   NODE_SOCKET_TYPES_END;
760
761   if (totitem == 0) {
762     *r_free = false;
763     return DummyRNA_NULL_items;
764   }
765
766   RNA_enum_item_end(&item, &totitem);
767   *r_free = true;
768
769   return item;
770 }
771
772 static const EnumPropertyItem *rna_node_static_type_itemf(bContext *UNUSED(C),
773                                                           PointerRNA *ptr,
774                                                           PropertyRNA *UNUSED(prop),
775                                                           bool *r_free)
776 {
777   EnumPropertyItem *item = NULL;
778   EnumPropertyItem tmp;
779   int totitem = 0;
780
781   /* hack, don't want to add include path to RNA just for this, since in the future RNA types
782    * for nodes should be defined locally at runtime anyway ...
783    */
784
785   tmp.value = NODE_CUSTOM;
786   tmp.identifier = "CUSTOM";
787   tmp.name = "Custom";
788   tmp.description = "Custom Node";
789   tmp.icon = ICON_NONE;
790   RNA_enum_item_add(&item, &totitem, &tmp);
791
792   tmp.value = NODE_CUSTOM_GROUP;
793   tmp.identifier = "CUSTOM GROUP";
794   tmp.name = "CustomGroup";
795   tmp.description = "Custom Group Node";
796   tmp.icon = ICON_NONE;
797   RNA_enum_item_add(&item, &totitem, &tmp);
798
799   tmp.value = NODE_UNDEFINED;
800   tmp.identifier = "UNDEFINED";
801   tmp.name = "UNDEFINED";
802   tmp.description = "";
803   tmp.icon = ICON_NONE;
804   RNA_enum_item_add(&item, &totitem, &tmp);
805
806 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
807     if (STREQ(#Category, "Node")) { \
808       tmp.value = ID; \
809       tmp.identifier = EnumName; \
810       tmp.name = UIName; \
811       tmp.description = UIDesc; \
812       tmp.icon = ICON_NONE; \
813       RNA_enum_item_add(&item, &totitem, &tmp); \
814     }
815 #  include "../../nodes/NOD_static_types.h"
816 #  undef DefNode
817
818   if (RNA_struct_is_a(ptr->type, &RNA_ShaderNode)) {
819 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
820     if (STREQ(#Category, "ShaderNode")) { \
821       tmp.value = ID; \
822       tmp.identifier = EnumName; \
823       tmp.name = UIName; \
824       tmp.description = UIDesc; \
825       tmp.icon = ICON_NONE; \
826       RNA_enum_item_add(&item, &totitem, &tmp); \
827     }
828 #  include "../../nodes/NOD_static_types.h"
829 #  undef DefNode
830   }
831
832   if (RNA_struct_is_a(ptr->type, &RNA_CompositorNode)) {
833 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
834     if (STREQ(#Category, "CompositorNode")) { \
835       tmp.value = ID; \
836       tmp.identifier = EnumName; \
837       tmp.name = UIName; \
838       tmp.description = UIDesc; \
839       tmp.icon = ICON_NONE; \
840       RNA_enum_item_add(&item, &totitem, &tmp); \
841     }
842 #  include "../../nodes/NOD_static_types.h"
843 #  undef DefNode
844   }
845
846   if (RNA_struct_is_a(ptr->type, &RNA_TextureNode)) {
847 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
848     if (STREQ(#Category, "TextureNode")) { \
849       tmp.value = ID; \
850       tmp.identifier = EnumName; \
851       tmp.name = UIName; \
852       tmp.description = UIDesc; \
853       tmp.icon = ICON_NONE; \
854       RNA_enum_item_add(&item, &totitem, &tmp); \
855     }
856 #  include "../../nodes/NOD_static_types.h"
857 #  undef DefNode
858   }
859
860   if (RNA_struct_is_a(ptr->type, &RNA_GeometryNode)) {
861 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
862     if (STREQ(#Category, "GeometryNode")) { \
863       tmp.value = ID; \
864       tmp.identifier = EnumName; \
865       tmp.name = UIName; \
866       tmp.description = UIDesc; \
867       tmp.icon = ICON_NONE; \
868       RNA_enum_item_add(&item, &totitem, &tmp); \
869     }
870 #  include "../../nodes/NOD_static_types.h"
871 #  undef DefNode
872   }
873
874   if (RNA_struct_is_a(ptr->type, &RNA_FunctionNode)) {
875 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
876     if (STREQ(#Category, "FunctionNode")) { \
877       tmp.value = ID; \
878       tmp.identifier = EnumName; \
879       tmp.name = UIName; \
880       tmp.description = UIDesc; \
881       tmp.icon = ICON_NONE; \
882       RNA_enum_item_add(&item, &totitem, &tmp); \
883     }
884 #  include "../../nodes/NOD_static_types.h"
885 #  undef DefNode
886   }
887
888   RNA_enum_item_end(&item, &totitem);
889   *r_free = true;
890
891   return item;
892 }
893
894 /* ******** Node Tree ******** */
895
896 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
897 {
898   bNodeTree *ntree = (bNodeTree *)ptr->data;
899
900   if (ntree->typeinfo->rna_ext.srna) {
901     return ntree->typeinfo->rna_ext.srna;
902   }
903   else {
904     return &RNA_NodeTree;
905   }
906 }
907
908 static bool rna_NodeTree_poll(const bContext *C, bNodeTreeType *ntreetype)
909 {
910   extern FunctionRNA rna_NodeTree_poll_func;
911
912   PointerRNA ptr;
913   ParameterList list;
914   FunctionRNA *func;
915   void *ret;
916   bool visible;
917
918   RNA_pointer_create(NULL, ntreetype->rna_ext.srna, NULL, &ptr); /* dummy */
919   func = &rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
920
921   RNA_parameter_list_create(&list, &ptr, func);
922   RNA_parameter_set_lookup(&list, "context", &C);
923   ntreetype->rna_ext.call((bContext *)C, &ptr, func, &list);
924
925   RNA_parameter_get_lookup(&list, "visible", &ret);
926   visible = *(bool *)ret;
927
928   RNA_parameter_list_free(&list);
929
930   return visible;
931 }
932
933 static void rna_NodeTree_update_reg(bNodeTree *ntree)
934 {
935   extern FunctionRNA rna_NodeTree_update_func;
936
937   PointerRNA ptr;
938   ParameterList list;
939   FunctionRNA *func;
940
941   RNA_id_pointer_create(&ntree->id, &ptr);
942   func = &rna_NodeTree_update_func; /* RNA_struct_find_function(&ptr, "update"); */
943
944   RNA_parameter_list_create(&list, &ptr, func);
945   ntree->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
946
947   RNA_parameter_list_free(&list);
948 }
949
950 static void rna_NodeTree_get_from_context(
951     const bContext *C, bNodeTreeType *ntreetype, bNodeTree **r_ntree, ID **r_id, ID **r_from)
952 {
953   extern FunctionRNA rna_NodeTree_get_from_context_func;
954
955   PointerRNA ptr;
956   ParameterList list;
957   FunctionRNA *func;
958   void *ret1, *ret2, *ret3;
959
960   RNA_pointer_create(NULL, ntreetype->rna_ext.srna, NULL, &ptr); /* dummy */
961   /* RNA_struct_find_function(&ptr, "get_from_context"); */
962   func = &rna_NodeTree_get_from_context_func;
963
964   RNA_parameter_list_create(&list, &ptr, func);
965   RNA_parameter_set_lookup(&list, "context", &C);
966   ntreetype->rna_ext.call((bContext *)C, &ptr, func, &list);
967
968   RNA_parameter_get_lookup(&list, "result_1", &ret1);
969   RNA_parameter_get_lookup(&list, "result_2", &ret2);
970   RNA_parameter_get_lookup(&list, "result_3", &ret3);
971   *r_ntree = *(bNodeTree **)ret1;
972   *r_id = *(ID **)ret2;
973   *r_from = *(ID **)ret3;
974
975   RNA_parameter_list_free(&list);
976 }
977
978 static bool rna_NodeTree_valid_socket_type(eNodeSocketDatatype socket_type,
979                                            bNodeTreeType *ntreetype)
980 {
981   extern FunctionRNA rna_NodeTree_valid_socket_type_func;
982
983   PointerRNA ptr;
984   ParameterList list;
985   FunctionRNA *func;
986   void *ret;
987   bool valid;
988
989   RNA_pointer_create(NULL, ntreetype->rna_ext.srna, NULL, &ptr); /* dummy */
990   func = &rna_NodeTree_valid_socket_type_func;
991
992   RNA_parameter_list_create(&list, &ptr, func);
993   RNA_parameter_set_lookup(&list, "type", &socket_type);
994   ntreetype->rna_ext.call(NULL, &ptr, func, &list);
995
996   RNA_parameter_get_lookup(&list, "valid", &ret);
997   valid = *(bool *)ret;
998
999   RNA_parameter_list_free(&list);
1000
1001   return valid;
1002 }
1003
1004 static void rna_NodeTree_unregister(Main *UNUSED(bmain), StructRNA *type)
1005 {
1006   bNodeTreeType *nt = RNA_struct_blender_type_get(type);
1007
1008   if (!nt) {
1009     return;
1010   }
1011
1012   RNA_struct_free_extension(type, &nt->rna_ext);
1013   RNA_struct_free(&BLENDER_RNA, type);
1014
1015   ntreeTypeFreeLink(nt);
1016
1017   /* update while blender is running */
1018   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1019 }
1020
1021 static StructRNA *rna_NodeTree_register(Main *bmain,
1022                                         ReportList *reports,
1023                                         void *data,
1024                                         const char *identifier,
1025                                         StructValidateFunc validate,
1026                                         StructCallbackFunc call,
1027                                         StructFreeFunc free)
1028 {
1029   bNodeTreeType *nt, dummynt;
1030   bNodeTree dummyntree;
1031   PointerRNA dummyptr;
1032   int have_function[4];
1033
1034   /* setup dummy tree & tree type to store static properties in */
1035   memset(&dummynt, 0, sizeof(bNodeTreeType));
1036   memset(&dummyntree, 0, sizeof(bNodeTree));
1037   dummyntree.typeinfo = &dummynt;
1038   RNA_pointer_create(NULL, &RNA_NodeTree, &dummyntree, &dummyptr);
1039
1040   /* validate the python class */
1041   if (validate(&dummyptr, data, have_function) != 0) {
1042     return NULL;
1043   }
1044
1045   if (strlen(identifier) >= sizeof(dummynt.idname)) {
1046     BKE_reportf(reports,
1047                 RPT_ERROR,
1048                 "Registering node tree class: '%s' is too long, maximum length is %d",
1049                 identifier,
1050                 (int)sizeof(dummynt.idname));
1051     return NULL;
1052   }
1053
1054   /* check if we have registered this tree type before, and remove it */
1055   nt = ntreeTypeFind(dummynt.idname);
1056   if (nt) {
1057     rna_NodeTree_unregister(bmain, nt->rna_ext.srna);
1058   }
1059
1060   /* create a new node tree type */
1061   nt = MEM_mallocN(sizeof(bNodeTreeType), "node tree type");
1062   memcpy(nt, &dummynt, sizeof(dummynt));
1063
1064   nt->type = NTREE_CUSTOM;
1065
1066   nt->rna_ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, &RNA_NodeTree);
1067   nt->rna_ext.data = data;
1068   nt->rna_ext.call = call;
1069   nt->rna_ext.free = free;
1070   RNA_struct_blender_type_set(nt->rna_ext.srna, nt);
1071
1072   RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name, nt->ui_description);
1073   RNA_def_struct_ui_icon(nt->rna_ext.srna, nt->ui_icon);
1074
1075   nt->poll = (have_function[0]) ? rna_NodeTree_poll : NULL;
1076   nt->update = (have_function[1]) ? rna_NodeTree_update_reg : NULL;
1077   nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : NULL;
1078   nt->valid_socket_type = (have_function[3]) ? rna_NodeTree_valid_socket_type : NULL;
1079
1080   ntreeTypeAdd(nt);
1081
1082   /* update while blender is running */
1083   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1084
1085   return nt->rna_ext.srna;
1086 }
1087
1088 static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports)
1089 {
1090   if (!ntreeIsRegistered(ntree)) {
1091     if (reports) {
1092       BKE_reportf(reports,
1093                   RPT_ERROR,
1094                   "Node tree '%s' has undefined type %s",
1095                   ntree->id.name + 2,
1096                   ntree->idname);
1097     }
1098     return false;
1099   }
1100   else {
1101     return true;
1102   }
1103 }
1104
1105 static void rna_NodeTree_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1106 {
1107   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
1108
1109   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1110   WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
1111
1112   ED_node_tag_update_nodetree(bmain, ntree, NULL);
1113 }
1114
1115 static bNode *rna_NodeTree_node_new(bNodeTree *ntree,
1116                                     bContext *C,
1117                                     ReportList *reports,
1118                                     const char *type)
1119 {
1120   bNodeType *ntype;
1121   bNode *node;
1122
1123   if (!rna_NodeTree_check(ntree, reports)) {
1124     return NULL;
1125   }
1126
1127   ntype = nodeTypeFind(type);
1128   if (!ntype) {
1129     BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type);
1130     return NULL;
1131   }
1132
1133   const char *disabled_hint = NULL;
1134   if (ntype->poll && !ntype->poll(ntype, ntree, &disabled_hint)) {
1135     if (disabled_hint) {
1136       BKE_reportf(reports,
1137                   RPT_ERROR,
1138                   "Cannot add node of type %s to node tree '%s'\n  %s",
1139                   type,
1140                   ntree->id.name + 2,
1141                   disabled_hint);
1142       return NULL;
1143     }
1144     else {
1145       BKE_reportf(reports,
1146                   RPT_ERROR,
1147                   "Cannot add node of type %s to node tree '%s'",
1148                   type,
1149                   ntree->id.name + 2);
1150       return NULL;
1151     }
1152   }
1153
1154   node = nodeAddNode(C, ntree, type);
1155   BLI_assert(node && node->typeinfo);
1156
1157   if (ntree->type == NTREE_TEXTURE) {
1158     ntreeTexCheckCyclics(ntree);
1159   }
1160
1161   ntreeUpdateTree(CTX_data_main(C), ntree);
1162   nodeUpdate(ntree, node);
1163   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1164
1165   return node;
1166 }
1167
1168 static void rna_NodeTree_node_remove(bNodeTree *ntree,
1169                                      Main *bmain,
1170                                      ReportList *reports,
1171                                      PointerRNA *node_ptr)
1172 {
1173   bNode *node = node_ptr->data;
1174
1175   if (!rna_NodeTree_check(ntree, reports)) {
1176     return;
1177   }
1178
1179   if (BLI_findindex(&ntree->nodes, node) == -1) {
1180     BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
1181     return;
1182   }
1183
1184   nodeRemoveNode(bmain, ntree, node, true);
1185
1186   RNA_POINTER_INVALIDATE(node_ptr);
1187
1188   ntreeUpdateTree(bmain, ntree); /* update group node socket links */
1189   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1190 }
1191
1192 static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1193 {
1194   bNode *node = ntree->nodes.first;
1195
1196   if (!rna_NodeTree_check(ntree, reports)) {
1197     return;
1198   }
1199
1200   while (node) {
1201     bNode *next_node = node->next;
1202
1203     nodeRemoveNode(bmain, ntree, node, true);
1204
1205     node = next_node;
1206   }
1207
1208   ntreeUpdateTree(bmain, ntree);
1209
1210   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1211 }
1212
1213 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
1214 {
1215   bNodeTree *ntree = (bNodeTree *)ptr->data;
1216   bNode *node = nodeGetActive(ntree);
1217   return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
1218 }
1219
1220 static void rna_NodeTree_active_node_set(PointerRNA *ptr,
1221                                          const PointerRNA value,
1222                                          struct ReportList *UNUSED(reports))
1223 {
1224   bNodeTree *ntree = (bNodeTree *)ptr->data;
1225   bNode *node = (bNode *)value.data;
1226
1227   if (node && BLI_findindex(&ntree->nodes, node) != -1) {
1228     nodeSetActive(ntree, node);
1229   }
1230   else {
1231     nodeClearActive(ntree);
1232   }
1233 }
1234
1235 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree,
1236                                         Main *bmain,
1237                                         ReportList *reports,
1238                                         bNodeSocket *fromsock,
1239                                         bNodeSocket *tosock,
1240                                         bool verify_limits)
1241 {
1242   bNodeLink *ret;
1243   bNode *fromnode = NULL, *tonode = NULL;
1244
1245   if (!rna_NodeTree_check(ntree, reports)) {
1246     return NULL;
1247   }
1248
1249   nodeFindNode(ntree, fromsock, &fromnode, NULL);
1250   nodeFindNode(ntree, tosock, &tonode, NULL);
1251   /* check validity of the sockets:
1252    * if sockets from different trees are passed in this will fail!
1253    */
1254   if (!fromnode || !tonode) {
1255     return NULL;
1256   }
1257
1258   if (&fromsock->in_out == &tosock->in_out) {
1259     BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
1260     return NULL;
1261   }
1262
1263   if (verify_limits) {
1264     /* remove other socket links if limit is exceeded */
1265     if (nodeCountSocketLinks(ntree, fromsock) + 1 > nodeSocketLinkLimit(fromsock)) {
1266       nodeRemSocketLinks(ntree, fromsock);
1267     }
1268     if (nodeCountSocketLinks(ntree, tosock) + 1 > nodeSocketLinkLimit(tosock)) {
1269       nodeRemSocketLinks(ntree, tosock);
1270     }
1271   }
1272
1273   ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
1274
1275   if (ret) {
1276
1277     /* not an issue from the UI, clear hidden from API to keep valid state. */
1278     fromsock->flag &= ~SOCK_HIDDEN;
1279     tosock->flag &= ~SOCK_HIDDEN;
1280
1281     if (tonode) {
1282       nodeUpdate(ntree, tonode);
1283     }
1284
1285     ntreeUpdateTree(bmain, ntree);
1286
1287     ED_node_tag_update_nodetree(bmain, ntree, ret->tonode);
1288     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1289   }
1290   return ret;
1291 }
1292
1293 static void rna_NodeTree_link_remove(bNodeTree *ntree,
1294                                      Main *bmain,
1295                                      ReportList *reports,
1296                                      PointerRNA *link_ptr)
1297 {
1298   bNodeLink *link = link_ptr->data;
1299
1300   if (!rna_NodeTree_check(ntree, reports)) {
1301     return;
1302   }
1303
1304   if (BLI_findindex(&ntree->links, link) == -1) {
1305     BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
1306     return;
1307   }
1308
1309   nodeRemLink(ntree, link);
1310   RNA_POINTER_INVALIDATE(link_ptr);
1311
1312   ntreeUpdateTree(bmain, ntree);
1313   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1314 }
1315
1316 static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1317 {
1318   bNodeLink *link = ntree->links.first;
1319
1320   if (!rna_NodeTree_check(ntree, reports)) {
1321     return;
1322   }
1323
1324   while (link) {
1325     bNodeLink *next_link = link->next;
1326
1327     nodeRemLink(ntree, link);
1328
1329     link = next_link;
1330   }
1331   ntreeUpdateTree(bmain, ntree);
1332
1333   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1334 }
1335
1336 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
1337 {
1338   bNodeTree *ntree = (bNodeTree *)ptr->data;
1339   int index = 0;
1340   LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &ntree->inputs, index) {
1341     if (socket->flag & SELECT) {
1342       return index;
1343     }
1344   }
1345   return -1;
1346 }
1347
1348 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
1349 {
1350   bNodeTree *ntree = (bNodeTree *)ptr->data;
1351
1352   int index = 0;
1353   LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &ntree->inputs, index) {
1354     SET_FLAG_FROM_TEST(socket->flag, index == value, SELECT);
1355   }
1356 }
1357
1358 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
1359 {
1360   bNodeTree *ntree = (bNodeTree *)ptr->data;
1361   int index = 0;
1362   LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &ntree->outputs, index) {
1363     if (socket->flag & SELECT) {
1364       return index;
1365     }
1366   }
1367   return -1;
1368 }
1369
1370 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
1371 {
1372   bNodeTree *ntree = (bNodeTree *)ptr->data;
1373
1374   int index = 0;
1375   LISTBASE_FOREACH_INDEX (bNodeSocket *, socket, &ntree->outputs, index) {
1376     SET_FLAG_FROM_TEST(socket->flag, index == value, SELECT);
1377   }
1378 }
1379
1380 static bNodeSocket *rna_NodeTree_inputs_new(
1381     bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
1382 {
1383   if (!rna_NodeTree_check(ntree, reports)) {
1384     return NULL;
1385   }
1386
1387   bNodeSocket *sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
1388
1389   ntreeUpdateTree(bmain, ntree);
1390   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1391
1392   return sock;
1393 }
1394
1395 static bNodeSocket *rna_NodeTree_outputs_new(
1396     bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
1397 {
1398   if (!rna_NodeTree_check(ntree, reports)) {
1399     return NULL;
1400   }
1401
1402   bNodeSocket *sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
1403
1404   ntreeUpdateTree(bmain, ntree);
1405   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1406
1407   return sock;
1408 }
1409
1410 static void rna_NodeTree_socket_remove(bNodeTree *ntree,
1411                                        Main *bmain,
1412                                        ReportList *reports,
1413                                        bNodeSocket *sock)
1414 {
1415   if (!rna_NodeTree_check(ntree, reports)) {
1416     return;
1417   }
1418
1419   if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
1420     BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1421   }
1422   else {
1423     ntreeRemoveSocketInterface(ntree, sock);
1424
1425     ntreeUpdateTree(bmain, ntree);
1426     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1427   }
1428 }
1429
1430 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1431 {
1432   if (!rna_NodeTree_check(ntree, reports)) {
1433     return;
1434   }
1435
1436   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, socket, &ntree->inputs) {
1437     ntreeRemoveSocketInterface(ntree, socket);
1438   }
1439
1440   ntreeUpdateTree(bmain, ntree);
1441   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1442 }
1443
1444 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1445 {
1446   if (!rna_NodeTree_check(ntree, reports)) {
1447     return;
1448   }
1449
1450   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, socket, &ntree->outputs) {
1451     ntreeRemoveSocketInterface(ntree, socket);
1452   }
1453
1454   ntreeUpdateTree(bmain, ntree);
1455   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1456 }
1457
1458 static void rna_NodeTree_inputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1459 {
1460   if (from_index == to_index) {
1461     return;
1462   }
1463   if (from_index < 0 || to_index < 0) {
1464     return;
1465   }
1466
1467   bNodeSocket *sock = BLI_findlink(&ntree->inputs, from_index);
1468   if (to_index < from_index) {
1469     bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
1470     if (nextsock) {
1471       BLI_remlink(&ntree->inputs, sock);
1472       BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
1473     }
1474   }
1475   else {
1476     bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
1477     if (prevsock) {
1478       BLI_remlink(&ntree->inputs, sock);
1479       BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1480     }
1481   }
1482
1483   ntree->update |= NTREE_UPDATE_GROUP_IN;
1484
1485   ntreeUpdateTree(bmain, ntree);
1486   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1487 }
1488
1489 static void rna_NodeTree_outputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1490 {
1491   if (from_index == to_index) {
1492     return;
1493   }
1494   if (from_index < 0 || to_index < 0) {
1495     return;
1496   }
1497
1498   bNodeSocket *sock = BLI_findlink(&ntree->outputs, from_index);
1499   if (to_index < from_index) {
1500     bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1501     if (nextsock) {
1502       BLI_remlink(&ntree->outputs, sock);
1503       BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1504     }
1505   }
1506   else {
1507     bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1508     if (prevsock) {
1509       BLI_remlink(&ntree->outputs, sock);
1510       BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1511     }
1512   }
1513
1514   ntree->update |= NTREE_UPDATE_GROUP_OUT;
1515
1516   ntreeUpdateTree(bmain, ntree);
1517   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1518 }
1519
1520 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1521 {
1522   Main *bmain = CTX_data_main(C);
1523
1524   ntree->update |= NTREE_UPDATE_GROUP;
1525   ntreeUpdateTree(bmain, ntree);
1526
1527   ED_node_tag_update_nodetree(bmain, ntree, NULL);
1528 }
1529
1530 /* ******** NodeLink ******** */
1531
1532 static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1533 {
1534   bNodeLink *link = ptr->data;
1535   return nodeLinkIsHidden(link);
1536 }
1537
1538 /* ******** Node ******** */
1539
1540 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1541 {
1542   bNode *node = (bNode *)ptr->data;
1543
1544   if (node->typeinfo->rna_ext.srna) {
1545     return node->typeinfo->rna_ext.srna;
1546   }
1547   else {
1548     return ptr->type;
1549   }
1550 }
1551
1552 static char *rna_Node_path(PointerRNA *ptr)
1553 {
1554   bNode *node = (bNode *)ptr->data;
1555   char name_esc[sizeof(node->name) * 2];
1556
1557   BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1558   return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1559 }
1560
1561 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1562 {
1563   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
1564   bNode *node;
1565   char name_esc[sizeof(node->name) * 2];
1566
1567   for (node = ntree->nodes.first; node; node = node->next) {
1568     if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1569       NodeTexEnvironment *data = node->storage;
1570       if (&data->iuser != ptr->data) {
1571         continue;
1572       }
1573     }
1574     else if (node->type == SH_NODE_TEX_IMAGE) {
1575       NodeTexImage *data = node->storage;
1576       if (&data->iuser != ptr->data) {
1577         continue;
1578       }
1579     }
1580     else {
1581       continue;
1582     }
1583
1584     BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1585     return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1586   }
1587
1588   return NULL;
1589 }
1590
1591 static bool rna_Node_poll(bNodeType *ntype, bNodeTree *ntree, const char **UNUSED(r_disabled_hint))
1592 {
1593   extern FunctionRNA rna_Node_poll_func;
1594
1595   PointerRNA ptr;
1596   ParameterList list;
1597   FunctionRNA *func;
1598   void *ret;
1599   bool visible;
1600
1601   RNA_pointer_create(NULL, ntype->rna_ext.srna, NULL, &ptr); /* dummy */
1602   func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1603
1604   RNA_parameter_list_create(&list, &ptr, func);
1605   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1606   ntype->rna_ext.call(NULL, &ptr, func, &list);
1607
1608   RNA_parameter_get_lookup(&list, "visible", &ret);
1609   visible = *(bool *)ret;
1610
1611   RNA_parameter_list_free(&list);
1612
1613   return visible;
1614 }
1615
1616 static bool rna_Node_poll_instance(bNode *node,
1617                                    bNodeTree *ntree,
1618                                    const char **UNUSED(disabled_info))
1619 {
1620   extern FunctionRNA rna_Node_poll_instance_func;
1621
1622   PointerRNA ptr;
1623   ParameterList list;
1624   FunctionRNA *func;
1625   void *ret;
1626   bool visible;
1627
1628   RNA_pointer_create(NULL, node->typeinfo->rna_ext.srna, node, &ptr); /* dummy */
1629   func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1630
1631   RNA_parameter_list_create(&list, &ptr, func);
1632   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1633   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1634
1635   RNA_parameter_get_lookup(&list, "visible", &ret);
1636   visible = *(bool *)ret;
1637
1638   RNA_parameter_list_free(&list);
1639
1640   return visible;
1641 }
1642
1643 static bool rna_Node_poll_instance_default(bNode *node,
1644                                            bNodeTree *ntree,
1645                                            const char **disabled_info)
1646 {
1647   /* use the basic poll function */
1648   return rna_Node_poll(node->typeinfo, ntree, disabled_info);
1649 }
1650
1651 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1652 {
1653   extern FunctionRNA rna_Node_update_func;
1654
1655   PointerRNA ptr;
1656   ParameterList list;
1657   FunctionRNA *func;
1658
1659   RNA_pointer_create((ID *)ntree, node->typeinfo->rna_ext.srna, node, &ptr);
1660   func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1661
1662   RNA_parameter_list_create(&list, &ptr, func);
1663   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1664
1665   RNA_parameter_list_free(&list);
1666 }
1667
1668 static void rna_Node_insert_link(bNodeTree *ntree, bNode *node, bNodeLink *link)
1669 {
1670   extern FunctionRNA rna_Node_insert_link_func;
1671
1672   PointerRNA ptr;
1673   ParameterList list;
1674   FunctionRNA *func;
1675
1676   RNA_pointer_create((ID *)ntree, node->typeinfo->rna_ext.srna, node, &ptr);
1677   func = &rna_Node_insert_link_func;
1678
1679   RNA_parameter_list_create(&list, &ptr, func);
1680   RNA_parameter_set_lookup(&list, "link", &link);
1681   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1682
1683   RNA_parameter_list_free(&list);
1684 }
1685
1686 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1687 {
1688   extern FunctionRNA rna_Node_init_func;
1689
1690   bNode *node = (bNode *)ptr->data;
1691   ParameterList list;
1692   FunctionRNA *func;
1693
1694   func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1695
1696   RNA_parameter_list_create(&list, ptr, func);
1697   node->typeinfo->rna_ext.call((bContext *)C, ptr, func, &list);
1698
1699   RNA_parameter_list_free(&list);
1700 }
1701
1702 static void rna_Node_copy(PointerRNA *ptr, const struct bNode *copynode)
1703 {
1704   extern FunctionRNA rna_Node_copy_func;
1705
1706   bNode *node = (bNode *)ptr->data;
1707   ParameterList list;
1708   FunctionRNA *func;
1709
1710   func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1711
1712   RNA_parameter_list_create(&list, ptr, func);
1713   RNA_parameter_set_lookup(&list, "node", &copynode);
1714   node->typeinfo->rna_ext.call(NULL, ptr, func, &list);
1715
1716   RNA_parameter_list_free(&list);
1717 }
1718
1719 static void rna_Node_free(PointerRNA *ptr)
1720 {
1721   extern FunctionRNA rna_Node_free_func;
1722
1723   bNode *node = (bNode *)ptr->data;
1724   ParameterList list;
1725   FunctionRNA *func;
1726
1727   func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1728
1729   RNA_parameter_list_create(&list, ptr, func);
1730   node->typeinfo->rna_ext.call(NULL, ptr, func, &list);
1731
1732   RNA_parameter_list_free(&list);
1733 }
1734
1735 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1736 {
1737   extern FunctionRNA rna_Node_draw_buttons_func;
1738
1739   bNode *node = (bNode *)ptr->data;
1740   ParameterList list;
1741   FunctionRNA *func;
1742
1743   func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1744
1745   RNA_parameter_list_create(&list, ptr, func);
1746   RNA_parameter_set_lookup(&list, "context", &C);
1747   RNA_parameter_set_lookup(&list, "layout", &layout);
1748   node->typeinfo->rna_ext.call(C, ptr, func, &list);
1749
1750   RNA_parameter_list_free(&list);
1751 }
1752
1753 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1754 {
1755   extern FunctionRNA rna_Node_draw_buttons_ext_func;
1756
1757   bNode *node = (bNode *)ptr->data;
1758   ParameterList list;
1759   FunctionRNA *func;
1760
1761   func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1762
1763   RNA_parameter_list_create(&list, ptr, func);
1764   RNA_parameter_set_lookup(&list, "context", &C);
1765   RNA_parameter_set_lookup(&list, "layout", &layout);
1766   node->typeinfo->rna_ext.call(C, ptr, func, &list);
1767
1768   RNA_parameter_list_free(&list);
1769 }
1770
1771 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1772 {
1773   extern FunctionRNA rna_Node_draw_label_func;
1774
1775   PointerRNA ptr;
1776   ParameterList list;
1777   FunctionRNA *func;
1778   void *ret;
1779   char *rlabel;
1780
1781   func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1782
1783   RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1784   RNA_parameter_list_create(&list, &ptr, func);
1785   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1786
1787   RNA_parameter_get_lookup(&list, "label", &ret);
1788   rlabel = (char *)ret;
1789   BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1790
1791   RNA_parameter_list_free(&list);
1792 }
1793
1794 static bool rna_Node_is_registered_node_type(StructRNA *type)
1795 {
1796   return (RNA_struct_blender_type_get(type) != NULL);
1797 }
1798
1799 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C),
1800                                                      ReportList *UNUSED(reports),
1801                                                      PointerRNA *ptr,
1802                                                      ParameterList *parms)
1803 {
1804   int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1805   RNA_parameter_set_lookup(parms, "result", &result);
1806 }
1807
1808 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1809 {
1810   bNodeType *nt = RNA_struct_blender_type_get(type);
1811
1812   if (!nt) {
1813     return;
1814   }
1815
1816   RNA_struct_free_extension(type, &nt->rna_ext);
1817   RNA_struct_free(&BLENDER_RNA, type);
1818
1819   /* this also frees the allocated nt pointer, no MEM_free call needed! */
1820   nodeUnregisterType(nt);
1821
1822   /* update while blender is running */
1823   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1824 }
1825
1826 /* Generic internal registration function.
1827  * Can be used to implement callbacks for registerable RNA node subtypes.
1828  */
1829 static bNodeType *rna_Node_register_base(Main *bmain,
1830                                          ReportList *reports,
1831                                          StructRNA *basetype,
1832                                          void *data,
1833                                          const char *identifier,
1834                                          StructValidateFunc validate,
1835                                          StructCallbackFunc call,
1836                                          StructFreeFunc free)
1837 {
1838   bNodeType *nt, dummynt;
1839   bNode dummynode;
1840   PointerRNA dummyptr;
1841   FunctionRNA *func;
1842   PropertyRNA *parm;
1843   int have_function[10];
1844
1845   /* setup dummy node & node type to store static properties in */
1846   memset(&dummynt, 0, sizeof(bNodeType));
1847   /* this does some additional initialization of default values */
1848   node_type_base_custom(&dummynt, identifier, "", 0, 0);
1849
1850   memset(&dummynode, 0, sizeof(bNode));
1851   dummynode.typeinfo = &dummynt;
1852   RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1853
1854   /* validate the python class */
1855   if (validate(&dummyptr, data, have_function) != 0) {
1856     return NULL;
1857   }
1858
1859   if (strlen(identifier) >= sizeof(dummynt.idname)) {
1860     BKE_reportf(reports,
1861                 RPT_ERROR,
1862                 "Registering node class: '%s' is too long, maximum length is %d",
1863                 identifier,
1864                 (int)sizeof(dummynt.idname));
1865     return NULL;
1866   }
1867
1868   /* check if we have registered this node type before, and remove it */
1869   nt = nodeTypeFind(dummynt.idname);
1870   if (nt) {
1871     rna_Node_unregister(bmain, nt->rna_ext.srna);
1872   }
1873
1874   /* create a new node type */
1875   nt = MEM_mallocN(sizeof(bNodeType), "node type");
1876   memcpy(nt, &dummynt, sizeof(dummynt));
1877   nt->free_self = (void (*)(bNodeType *))MEM_freeN;
1878
1879   nt->rna_ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1880   nt->rna_ext.data = data;
1881   nt->rna_ext.call = call;
1882   nt->rna_ext.free = free;
1883   RNA_struct_blender_type_set(nt->rna_ext.srna, nt);
1884
1885   RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name, nt->ui_description);
1886   RNA_def_struct_ui_icon(nt->rna_ext.srna, nt->ui_icon);
1887
1888   func = RNA_def_function_runtime(
1889       nt->rna_ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1890   RNA_def_function_ui_description(func, "True if a registered node type");
1891   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1892   parm = RNA_def_boolean(func, "result", false, "Result", "");
1893   RNA_def_function_return(func, parm);
1894
1895   /* XXX bad level call! needed to initialize the basic draw functions ... */
1896   ED_init_custom_node_type(nt);
1897
1898   nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1899   nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1900   nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1901   nt->insert_link = (have_function[3]) ? rna_Node_insert_link : NULL;
1902   nt->initfunc_api = (have_function[4]) ? rna_Node_init : NULL;
1903   nt->copyfunc_api = (have_function[5]) ? rna_Node_copy : NULL;
1904   nt->freefunc_api = (have_function[6]) ? rna_Node_free : NULL;
1905   nt->draw_buttons = (have_function[7]) ? rna_Node_draw_buttons : NULL;
1906   nt->draw_buttons_ex = (have_function[8]) ? rna_Node_draw_buttons_ext : NULL;
1907   nt->labelfunc = (have_function[9]) ? rna_Node_draw_label : NULL;
1908
1909   /* sanitize size values in case not all have been registered */
1910   if (nt->maxwidth < nt->minwidth) {
1911     nt->maxwidth = nt->minwidth;
1912   }
1913   if (nt->maxheight < nt->minheight) {
1914     nt->maxheight = nt->minheight;
1915   }
1916   CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1917   CLAMP(nt->height, nt->minheight, nt->maxheight);
1918
1919   return nt;
1920 }
1921
1922 static StructRNA *rna_Node_register(Main *bmain,
1923                                     ReportList *reports,
1924                                     void *data,
1925                                     const char *identifier,
1926                                     StructValidateFunc validate,
1927                                     StructCallbackFunc call,
1928                                     StructFreeFunc free)
1929 {
1930   bNodeType *nt = rna_Node_register_base(
1931       bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1932   if (!nt) {
1933     return NULL;
1934   }
1935
1936   nodeRegisterType(nt);
1937
1938   /* update while blender is running */
1939   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1940
1941   return nt->rna_ext.srna;
1942 }
1943
1944 static const EnumPropertyItem *itemf_function_check(
1945     const EnumPropertyItem *original_item_array,
1946     bool (*value_supported)(const EnumPropertyItem *item))
1947 {
1948   EnumPropertyItem *item_array = NULL;
1949   int items_len = 0;
1950
1951   for (const EnumPropertyItem *item = original_item_array; item->identifier != NULL; item++) {
1952     if (value_supported(item)) {
1953       RNA_enum_item_add(&item_array, &items_len, item);
1954     }
1955   }
1956
1957   RNA_enum_item_end(&item_array, &items_len);
1958   return item_array;
1959 }
1960
1961 static bool switch_type_supported(const EnumPropertyItem *item)
1962 {
1963   return ELEM(item->value,
1964               SOCK_FLOAT,
1965               SOCK_INT,
1966               SOCK_BOOLEAN,
1967               SOCK_VECTOR,
1968               SOCK_STRING,
1969               SOCK_RGBA,
1970               SOCK_GEOMETRY,
1971               SOCK_OBJECT,
1972               SOCK_COLLECTION);
1973 }
1974
1975 static const EnumPropertyItem *rna_GeometryNodeSwitch_type_itemf(bContext *UNUSED(C),
1976                                                                  PointerRNA *UNUSED(ptr),
1977                                                                  PropertyRNA *UNUSED(prop),
1978                                                                  bool *r_free)
1979 {
1980   *r_free = true;
1981   return itemf_function_check(node_socket_data_type_items, switch_type_supported);
1982 }
1983
1984 static bool attribute_clamp_type_supported(const EnumPropertyItem *item)
1985 {
1986   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_INT32, CD_PROP_COLOR);
1987 }
1988 static const EnumPropertyItem *rna_GeometryNodeAttributeClamp_type_itemf(bContext *UNUSED(C),
1989                                                                          PointerRNA *UNUSED(ptr),
1990                                                                          PropertyRNA *UNUSED(prop),
1991                                                                          bool *r_free)
1992 {
1993   *r_free = true;
1994   return itemf_function_check(rna_enum_attribute_type_items, attribute_clamp_type_supported);
1995 }
1996
1997 static bool attribute_random_type_supported(const EnumPropertyItem *item)
1998 {
1999   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_BOOL, CD_PROP_INT32);
2000 }
2001 static const EnumPropertyItem *rna_GeometryNodeAttributeRandom_type_itemf(
2002     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2003 {
2004   *r_free = true;
2005   return itemf_function_check(rna_enum_attribute_type_items, attribute_random_type_supported);
2006 }
2007
2008 static const EnumPropertyItem *rna_GeometryNodeAttributeRandomize_operation_itemf(
2009     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2010 {
2011   bNode *node = ptr->data;
2012   const NodeAttributeRandomize *node_storage = (NodeAttributeRandomize *)node->storage;
2013   const CustomDataType data_type = (CustomDataType)node_storage->data_type;
2014
2015   EnumPropertyItem *item_array = NULL;
2016   int items_len = 0;
2017   for (const EnumPropertyItem *item = rna_node_geometry_attribute_randomize_operation_items;
2018        item->identifier != NULL;
2019        item++) {
2020     if (data_type == CD_PROP_BOOL) {
2021       if (item->value == GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE) {
2022         RNA_enum_item_add(&item_array, &items_len, item);
2023       }
2024     }
2025     else {
2026       RNA_enum_item_add(&item_array, &items_len, item);
2027     }
2028   }
2029   RNA_enum_item_end(&item_array, &items_len);
2030
2031   *r_free = true;
2032   return item_array;
2033 }
2034
2035 static void rna_GeometryNodeAttributeRandomize_data_type_update(Main *bmain,
2036                                                                 Scene *scene,
2037                                                                 PointerRNA *ptr)
2038 {
2039   bNode *node = ptr->data;
2040   NodeAttributeRandomize *node_storage = (NodeAttributeRandomize *)node->storage;
2041
2042   /* The boolean data type has no extra operations besides,
2043    * replace, so make sure the enum value is set properly. */
2044   if (node_storage->data_type == CD_PROP_BOOL) {
2045     node_storage->operation = GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE;
2046   }
2047
2048   rna_Node_socket_update(bmain, scene, ptr);
2049 }
2050
2051 static bool attribute_convert_type_supported(const EnumPropertyItem *item)
2052 {
2053   return ELEM(item->value,
2054               CD_AUTO_FROM_NAME,
2055               CD_PROP_FLOAT,
2056               CD_PROP_FLOAT2,
2057               CD_PROP_FLOAT3,
2058               CD_PROP_COLOR,
2059               CD_PROP_BOOL,
2060               CD_PROP_INT32);
2061 }
2062 static const EnumPropertyItem *rna_GeometryNodeAttributeConvert_type_itemf(
2063     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2064 {
2065   *r_free = true;
2066   return itemf_function_check(rna_enum_attribute_type_with_auto_items,
2067                               attribute_convert_type_supported);
2068 }
2069
2070 static bool attribute_fill_type_supported(const EnumPropertyItem *item)
2071 {
2072   return ELEM(
2073       item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_COLOR, CD_PROP_BOOL, CD_PROP_INT32);
2074 }
2075 static const EnumPropertyItem *rna_GeometryNodeAttributeFill_type_itemf(bContext *UNUSED(C),
2076                                                                         PointerRNA *UNUSED(ptr),
2077                                                                         PropertyRNA *UNUSED(prop),
2078                                                                         bool *r_free)
2079 {
2080   *r_free = true;
2081   return itemf_function_check(rna_enum_attribute_type_items, attribute_fill_type_supported);
2082 }
2083
2084 /**
2085  * This bit of ugly code makes sure the float / attribute option shows up instead of
2086  * vector / attribute if the node uses an operation that uses a float for input B or C.
2087  */
2088 static const EnumPropertyItem *rna_GeometryNodeAttributeVectorMath_input_type_b_itemf(
2089     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2090 {
2091   bNode *node = ptr->data;
2092   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2093
2094   EnumPropertyItem *item_array = NULL;
2095   int items_len = 0;
2096   for (const EnumPropertyItem *item = rna_node_geometry_attribute_input_type_items_any;
2097        item->identifier != NULL;
2098        item++) {
2099     if (item->value == GEO_NODE_ATTRIBUTE_INPUT_ATTRIBUTE) {
2100       RNA_enum_item_add(&item_array, &items_len, item);
2101     }
2102     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2103       if (node_storage->operation == NODE_VECTOR_MATH_SCALE) {
2104         RNA_enum_item_add(&item_array, &items_len, item);
2105       }
2106     }
2107     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2108       if (node_storage->operation != NODE_VECTOR_MATH_SCALE) {
2109         RNA_enum_item_add(&item_array, &items_len, item);
2110       }
2111     }
2112   }
2113   RNA_enum_item_end(&item_array, &items_len);
2114
2115   *r_free = true;
2116   return item_array;
2117 }
2118
2119 static const EnumPropertyItem *rna_GeometryNodeAttributeVectorMath_input_type_c_itemf(
2120     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2121 {
2122   bNode *node = ptr->data;
2123   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2124
2125   EnumPropertyItem *item_array = NULL;
2126   int items_len = 0;
2127   for (const EnumPropertyItem *item = rna_node_geometry_attribute_input_type_items_any;
2128        item->identifier != NULL;
2129        item++) {
2130     if (item->value == GEO_NODE_ATTRIBUTE_INPUT_ATTRIBUTE) {
2131       RNA_enum_item_add(&item_array, &items_len, item);
2132     }
2133     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2134       if (node_storage->operation == NODE_VECTOR_MATH_REFRACT) {
2135         RNA_enum_item_add(&item_array, &items_len, item);
2136       }
2137     }
2138     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2139       if (node_storage->operation != NODE_VECTOR_MATH_REFRACT) {
2140         RNA_enum_item_add(&item_array, &items_len, item);
2141       }
2142     }
2143   }
2144   RNA_enum_item_end(&item_array, &items_len);
2145
2146   *r_free = true;
2147   return item_array;
2148 }
2149
2150 static void rna_GeometryNodeAttributeVectorMath_operation_update(Main *bmain,
2151                                                                  Scene *scene,
2152                                                                  PointerRNA *ptr)
2153 {
2154   bNode *node = ptr->data;
2155   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2156
2157   const NodeVectorMathOperation operation = (NodeVectorMathOperation)node_storage->operation;
2158
2159   /* The scale operation can't use a vector input, so reset
2160    * the input type enum in case it's set to vector. */
2161   if (operation == NODE_VECTOR_MATH_SCALE) {
2162     if (node_storage->input_type_b == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2163       node_storage->input_type_b = GEO_NODE_ATTRIBUTE_INPUT_FLOAT;
2164     }
2165   }
2166
2167   /* Scale is also the only operation that uses the float input type, so a
2168    * a check is also necessary for the other direction. */
2169   if (operation != NODE_VECTOR_MATH_SCALE) {
2170     if (node_storage->input_type_b == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2171       node_storage->input_type_b = GEO_NODE_ATTRIBUTE_INPUT_VECTOR;
2172     }
2173   }
2174
2175   rna_Node_socket_update(bmain, scene, ptr);
2176 }
2177
2178 static bool attribute_map_range_type_supported(const EnumPropertyItem *item)
2179 {
2180   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3);
2181 }
2182 static const EnumPropertyItem *rna_GeometryNodeAttributeMapRange_type_itemf(
2183     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2184 {
2185   *r_free = true;
2186   return itemf_function_check(rna_enum_attribute_type_items, attribute_map_range_type_supported);
2187 }
2188
2189 static bool attribute_curve_map_type_supported(const EnumPropertyItem *item)
2190 {
2191   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_COLOR);
2192 }
2193 static const EnumPropertyItem *rna_GeometryNodeAttributeCurveMap_type_itemf(
2194     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2195 {
2196   *r_free = true;
2197   return itemf_function_check(rna_enum_attribute_type_items, attribute_curve_map_type_supported);
2198 }
2199
2200 static StructRNA *rna_ShaderNode_register(Main *bmain,
2201                                           ReportList *reports,
2202                                           void *data,
2203                                           const char *identifier,
2204                                           StructValidateFunc validate,
2205                                           StructCallbackFunc call,
2206                                           StructFreeFunc free)
2207 {
2208   bNodeType *nt = rna_Node_register_base(
2209       bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
2210   if (!nt) {
2211     return NULL;
2212   }
2213
2214   nodeRegisterType(nt);
2215
2216   /* update while blender is running */
2217   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2218
2219   return nt->rna_ext.srna;
2220 }
2221
2222 static StructRNA *rna_CompositorNode_register(Main *bmain,
2223                                               ReportList *reports,
2224                                               void *data,
2225                                               const char *identifier,
2226                                               StructValidateFunc validate,
2227                                               StructCallbackFunc call,
2228                                               StructFreeFunc free)
2229 {
2230   bNodeType *nt = rna_Node_register_base(
2231       bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
2232   if (!nt) {
2233     return NULL;
2234   }
2235
2236   nodeRegisterType(nt);
2237
2238   /* update while blender is running */
2239   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2240
2241   return nt->rna_ext.srna;
2242 }
2243
2244 static StructRNA *rna_TextureNode_register(Main *bmain,
2245                                            ReportList *reports,
2246                                            void *data,
2247                                            const char *identifier,
2248                                            StructValidateFunc validate,
2249                                            StructCallbackFunc call,
2250                                            StructFreeFunc free)
2251 {
2252   bNodeType *nt = rna_Node_register_base(
2253       bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
2254   if (!nt) {
2255     return NULL;
2256   }
2257
2258   nodeRegisterType(nt);
2259
2260   /* update while blender is running */
2261   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2262
2263   return nt->rna_ext.srna;
2264 }
2265
2266 static StructRNA *rna_GeometryNode_register(Main *bmain,
2267                                             ReportList *reports,
2268                                             void *data,
2269                                             const char *identifier,
2270                                             StructValidateFunc validate,
2271                                             StructCallbackFunc call,
2272                                             StructFreeFunc free)
2273 {
2274   bNodeType *nt = rna_Node_register_base(
2275       bmain, reports, &RNA_GeometryNode, data, identifier, validate, call, free);
2276   if (!nt) {
2277     return NULL;
2278   }
2279
2280   nodeRegisterType(nt);
2281
2282   /* update while blender is running */
2283   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2284
2285   return nt->rna_ext.srna;
2286 }
2287
2288 static StructRNA *rna_FunctionNode_register(Main *bmain,
2289                                             ReportList *reports,
2290                                             void *data,
2291                                             const char *identifier,
2292                                             StructValidateFunc validate,
2293                                             StructCallbackFunc call,
2294                                             StructFreeFunc free)
2295 {
2296   bNodeType *nt = rna_Node_register_base(
2297       bmain, reports, &RNA_FunctionNode, data, identifier, validate, call, free);
2298   if (!nt) {
2299     return NULL;
2300   }
2301
2302   nodeRegisterType(nt);
2303
2304   /* update while blender is running */
2305   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2306
2307   return nt->rna_ext.srna;
2308 }
2309
2310 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
2311 {
2312   bNode *node = ptr->data;
2313
2314   if (create && !node->prop) {
2315     IDPropertyTemplate val = {0};
2316     node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
2317   }
2318
2319   return node->prop;
2320 }
2321
2322 static void rna_Node_parent_set(PointerRNA *ptr,
2323                                 PointerRNA value,
2324                                 struct ReportList *UNUSED(reports))
2325 {
2326   bNode *node = ptr->data;
2327   bNode *parent = value.data;
2328
2329   if (parent) {
2330     /* XXX only Frame node allowed for now,
2331      * in the future should have a poll function or so to test possible attachment.
2332      */
2333     if (parent->type != NODE_FRAME) {
2334       return;
2335     }
2336
2337     /* make sure parent is not attached to the node */
2338     if (nodeAttachNodeCheck(parent, node)) {
2339       return;
2340     }
2341   }
2342
2343   nodeDetachNode(node);
2344   if (parent) {
2345     nodeAttachNode(node, parent);
2346   }
2347 }
2348
2349 static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
2350 {
2351   bNode *node = ptr->data;
2352   bNode *parent = value.data;
2353
2354   /* XXX only Frame node allowed for now,
2355    * in the future should have a poll function or so to test possible attachment.
2356    */
2357   if (parent->type != NODE_FRAME) {
2358     return false;
2359   }
2360
2361   /* make sure parent is not attached to the node */
2362   if (nodeAttachNodeCheck(parent, node)) {
2363     return false;
2364   }
2365
2366   return true;
2367 }
2368
2369 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2370 {
2371   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2372   bNode *node = (bNode *)ptr->data;
2373   ED_node_tag_update_nodetree(bmain, ntree, node);
2374 }
2375
2376 static void rna_Node_update_relations(Main *bmain, Scene *scene, PointerRNA *ptr)
2377 {
2378   rna_Node_update(bmain, scene, ptr);
2379   DEG_relations_tag_update(bmain);
2380 }
2381
2382 static void rna_Node_socket_value_update(ID *id, bNode *node, bContext *C)
2383 {
2384   ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id, node);
2385 }
2386
2387 static void rna_Node_select_set(PointerRNA *ptr, bool value)
2388 {
2389   bNode *node = (bNode *)ptr->data;
2390   nodeSetSelected(node, value);
2391 }
2392
2393 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
2394 {
2395   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2396   bNode *node = (bNode *)ptr->data;
2397   char oldname[sizeof(node->name)];
2398
2399   /* make a copy of the old name first */
2400   BLI_strncpy(oldname, node->name, sizeof(node->name));
2401   /* set new name */
2402   BLI_strncpy_utf8(node->name, value, sizeof(node->name));
2403
2404   nodeUniqueName(ntree, node);
2405
2406   /* fix all the animation data which may link to this */
2407   BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
2408 }
2409
2410 static bNodeSocket *rna_Node_inputs_new(ID *id,
2411                                         bNode *node,
2412                                         Main *bmain,
2413                                         ReportList *reports,
2414                                         const char *type,
2415                                         const char *name,
2416                                         const char *identifier)
2417 {
2418
2419   if (ELEM(node->type, NODE_GROUP_INPUT, NODE_FRAME)) {
2420     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2421     return NULL;
2422   }
2423   /* Adding an input to a group node is not working,
2424    * simpler to add it to its underlying nodetree. */
2425   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
2426     return rna_NodeTree_inputs_new((bNodeTree *)node->id, bmain, reports, type, name);
2427   }
2428
2429   bNodeTree *ntree = (bNodeTree *)id;
2430   bNodeSocket *sock;
2431
2432   sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
2433
2434   if (sock == NULL) {
2435     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2436   }
2437   else {
2438     ntreeUpdateTree(bmain, ntree);
2439     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2440   }
2441
2442   return sock;
2443 }
2444
2445 static bNodeSocket *rna_Node_outputs_new(ID *id,
2446                                          bNode *node,
2447                                          Main *bmain,
2448                                          ReportList *reports,
2449                                          const char *type,
2450                                          const char *name,
2451                                          const char *identifier)
2452 {
2453   if (ELEM(node->type, NODE_GROUP_OUTPUT, NODE_FRAME)) {
2454     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2455     return NULL;
2456   }
2457   /* Adding an output to a group node is not working,
2458    * simpler to add it to its underlying nodetree. */
2459   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
2460     return rna_NodeTree_outputs_new((bNodeTree *)node->id, bmain, reports, type, name);
2461   }
2462
2463   bNodeTree *ntree = (bNodeTree *)id;
2464   bNodeSocket *sock;
2465
2466   sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
2467
2468   if (sock == NULL) {
2469     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2470   }
2471   else {
2472     ntreeUpdateTree(bmain, ntree);
2473     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2474   }
2475
2476   return sock;
2477 }
2478
2479 static void rna_Node_socket_remove(
2480     ID *id, bNode *node, Main *bmain, ReportList *reports, bNodeSocket *sock)
2481 {
2482   bNodeTree *ntree = (bNodeTree *)id;
2483
2484   if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
2485     BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
2486   }
2487   else {
2488     nodeRemoveSocket(ntree, node, sock);
2489
2490     ntreeUpdateTree(bmain, ntree);
2491     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2492   }
2493 }
2494
2495 static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain)
2496 {
2497   bNodeTree *ntree = (bNodeTree *)id;
2498   bNodeSocket *sock, *nextsock;
2499
2500   for (sock = node->inputs.first; sock; sock = nextsock) {
2501     nextsock = sock->next;
2502     nodeRemoveSocket(ntree, node, sock);
2503   }
2504
2505   ntreeUpdateTree(bmain, ntree);
2506   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2507 }
2508
2509 static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain)
2510 {
2511   bNodeTree *ntree = (bNodeTree *)id;
2512   bNodeSocket *sock, *nextsock;
2513
2514   for (sock = node->outputs.first; sock; sock = nextsock) {
2515     nextsock = sock->next;
2516     nodeRemoveSocket(ntree, node, sock);
2517   }
2518
2519   ntreeUpdateTree(bmain, ntree);
2520   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2521 }
2522
2523 static void rna_Node_inputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
2524 {
2525   bNodeTree *ntree = (bNodeTree *)id;
2526   bNodeSocket *sock;
2527
2528   if (from_index == to_index) {
2529     return;
2530   }
2531   if (from_index < 0 || to_index < 0) {
2532     return;
2533   }
2534
2535   sock = BLI_findlink(&node->inputs, from_index);
2536   if (to_index < from_index) {
2537     bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
2538     if (nextsock) {
2539       BLI_remlink(&node->inputs, sock);
2540       BLI_insertlinkbefore(&node->inputs, nextsock, sock);
2541     }
2542   }
2543   else {
2544     bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
2545     if (prevsock) {
2546       BLI_remlink(&node->inputs, sock);
2547       BLI_insertlinkafter(&node->inputs, prevsock, sock);
2548     }
2549   }
2550
2551   ntreeUpdateTree(bmain, ntree);
2552   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2553 }
2554
2555 static void rna_Node_outputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
2556 {
2557   bNodeTree *ntree = (bNodeTree *)id;
2558   bNodeSocket *sock;
2559
2560   if (from_index == to_index) {
2561     return;
2562   }
2563   if (from_index < 0 || to_index < 0) {
2564     return;
2565   }
2566
2567   sock = BLI_findlink(&node->outputs, from_index);
2568   if (to_index < from_index) {
2569     bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
2570     if (nextsock) {
2571       BLI_remlink(&node->outputs, sock);
2572       BLI_insertlinkbefore(&node->outputs, nextsock, sock);
2573     }
2574   }
2575   else {
2576     bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
2577     if (prevsock) {
2578       BLI_remlink(&node->outputs, sock);
2579       BLI_insertlinkafter(&node->outputs, prevsock, sock);
2580     }
2581   }
2582
2583   ntreeUpdateTree(bmain, ntree);
2584   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2585 }
2586
2587 static void rna_Node_width_range(
2588     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2589 {
2590   bNode *node = ptr->data;
2591   *min = *softmin = node->typeinfo->minwidth;
2592   *max = *softmax = node->typeinfo->maxwidth;
2593 }
2594
2595 static void rna_Node_height_range(
2596     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2597 {
2598   bNode *node = ptr->data;
2599   *min = *softmin = node->typeinfo->minheight;
2600   *max = *softmax = node->typeinfo->maxheight;
2601 }
2602
2603 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
2604 {
2605   bNode *node = ptr->data;
2606   value[0] = node->totr.xmax - node->totr.xmin;
2607   value[1] = node->totr.ymax - node->totr.ymin;
2608 }
2609
2610 /* ******** Node Socket ******** */
2611
2612 static void rna_NodeSocket_draw(
2613     bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
2614 {
2615   extern FunctionRNA rna_NodeSocket_draw_func;
2616
2617   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2618   ParameterList list;
2619   FunctionRNA *func;
2620
2621   func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2622
2623   RNA_parameter_list_create(&list, ptr, func);
2624   RNA_parameter_set_lookup(&list, "context", &C);
2625   RNA_parameter_set_lookup(&list, "layout", &layout);
2626   RNA_parameter_set_lookup(&list, "node", node_ptr);
2627   RNA_parameter_set_lookup(&list, "text", &text);
2628   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
2629
2630   RNA_parameter_list_free(&list);
2631 }
2632
2633 static void rna_NodeSocket_draw_color(bContext *C,
2634                                       PointerRNA *ptr,
2635                                       PointerRNA *node_ptr,
2636                                       float *r_color)
2637 {
2638   extern FunctionRNA rna_NodeSocket_draw_color_func;
2639
2640   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2641   ParameterList list;
2642   FunctionRNA *func;
2643   void *ret;
2644
2645   func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2646
2647   RNA_parameter_list_create(&list, ptr, func);
2648   RNA_parameter_set_lookup(&list, "context", &C);
2649   RNA_parameter_set_lookup(&list, "node", node_ptr);
2650   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
2651
2652   RNA_parameter_get_lookup(&list, "color", &ret);
2653   copy_v4_v4(r_color, (float *)ret);
2654
2655   RNA_parameter_list_free(&list);
2656 }
2657
2658 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
2659 {
2660   bNodeSocketType *st = RNA_struct_blender_type_get(type);
2661   if (!st) {
2662     return;
2663   }
2664
2665   RNA_struct_free_extension(type, &st->ext_socket);
2666   RNA_struct_free(&BLENDER_RNA, type);
2667
2668   nodeUnregisterSocketType(st);
2669
2670   /* update while blender is running */
2671   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2672 }
2673
2674 static StructRNA *rna_NodeSocket_register(Main *UNUSED(bmain),
2675                                           ReportList *reports,
2676                                           void *data,
2677                                           const char *identifier,
2678                                           StructValidateFunc validate,
2679                                           StructCallbackFunc call,
2680                                           StructFreeFunc free)
2681 {
2682   bNodeSocketType *st, dummyst;
2683   bNodeSocket dummysock;
2684   PointerRNA dummyptr;
2685   int have_function[2];
2686
2687   /* setup dummy socket & socket type to store static properties in */
2688   memset(&dummyst, 0, sizeof(bNodeSocketType));
2689
2690   memset(&dummysock, 0, sizeof(bNodeSocket));
2691   dummysock.typeinfo = &dummyst;
2692   RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
2693
2694   /* validate the python class */
2695   if (validate(&dummyptr, data, have_function) != 0) {
2696     return NULL;
2697   }
2698
2699   if (strlen(identifier) >= sizeof(dummyst.idname)) {
2700     BKE_reportf(reports,
2701                 RPT_ERROR,
2702                 "Registering node socket class: '%s' is too long, maximum length is %d",
2703                 identifier,
2704                 (int)sizeof(dummyst.idname));
2705     return NULL;
2706   }
2707
2708   /* check if we have registered this socket type before */
2709   st = nodeSocketTypeFind(dummyst.idname);
2710   if (!st) {
2711     /* create a new node socket type */
2712     st = MEM_mallocN(sizeof(bNodeSocketType), "node socket type");
2713     memcpy(st, &dummyst, sizeof(dummyst));
2714
2715     nodeRegisterSocketType(st);
2716   }
2717
2718   st->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
2719
2720   /* if RNA type is already registered, unregister first */
2721   if (st->ext_socket.srna) {
2722     StructRNA *srna = st->ext_socket.srna;
2723     RNA_struct_free_extension(srna, &st->ext_socket);
2724     RNA_struct_free(&BLENDER_RNA, srna);
2725   }
2726   st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket);
2727   st->ext_socket.data = data;
2728   st->ext_socket.call = call;
2729   st->ext_socket.free = free;
2730   RNA_struct_blender_type_set(st->ext_socket.srna, st);
2731
2732   /* XXX bad level call! needed to initialize the basic draw functions ... */
2733   ED_init_custom_node_socket_type(st);
2734
2735   st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
2736   st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
2737
2738   /* update while blender is running */
2739   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2740
2741   return st->ext_socket.srna;
2742 }
2743
2744 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
2745 {
2746   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2747
2748   if (sock->typeinfo->ext_socket.srna) {
2749     return sock->typeinfo->ext_socket.srna;
2750   }
2751   else {
2752     return &RNA_NodeSocket;
2753   }
2754 }
2755
2756 static char *rna_NodeSocket_path(PointerRNA *ptr)
2757 {
2758   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2759   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2760   bNode *node;
2761   int socketindex;
2762   char name_esc[sizeof(node->name) * 2];
2763
2764   if (!nodeFindNode(ntree, sock, &node, &socketindex)) {
2765     return NULL;
2766   }
2767
2768   BLI_str_escape(name_esc, node->name, sizeof(name_esc));
2769
2770   if (sock->in_out == SOCK_IN) {
2771     return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
2772   }
2773   else {
2774     return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
2775   }
2776 }
2777
2778 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
2779 {
2780   bNodeSocket *sock = ptr->data;
2781
2782   if (create && !sock->prop) {
2783     IDPropertyTemplate val = {0};
2784     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
2785   }
2786
2787   return sock->prop;
2788 }
2789
2790 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
2791 {
2792   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2793   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2794   bNode *node;
2795   PointerRNA r_ptr;
2796
2797   nodeFindNode(ntree, sock, &node, NULL);
2798
2799   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
2800   return r_ptr;
2801 }
2802
2803 static void rna_NodeSocket_type_set(PointerRNA *ptr, int value)
2804 {
2805   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2806   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2807   bNode *node;
2808   nodeFindNode(ntree, sock, &node, NULL);
2809   nodeModifySocketType(ntree, node, sock, value, 0);
2810 }
2811
2812 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2813 {
2814   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2815   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2816   bNode *node;
2817   if (nodeFindNode(ntree, sock, &node, NULL)) {
2818     ED_node_tag_update_nodetree(bmain, ntree, node);
2819   }
2820 }
2821
2822 static bool rna_NodeSocket_is_output_get(PointerRNA *ptr)
2823 {
2824   bNodeSocket *sock = ptr->data;
2825   return sock->in_out == SOCK_OUT;
2826 }
2827
2828 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
2829 {
2830   /* Does not have any effect if the link limit is defined in the socket type. */
2831   bNodeSocket *sock = ptr->data;
2832   sock->limit = (value == 0 ? 0xFFF : value);
2833 }
2834
2835 static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
2836 {
2837   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2838
2839   /* don't hide linked sockets */
2840   if (sock->flag & SOCK_IN_USE) {
2841     return;
2842   }
2843
2844   if (value) {
2845     sock->flag |= SOCK_HIDDEN;
2846   }
2847   else {
2848     sock->flag &= ~SOCK_HIDDEN;
2849   }
2850 }
2851
2852 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
2853 {
2854   extern FunctionRNA rna_NodeSocketInterface_draw_func;
2855
2856   bNodeSocket *stemp = (bNodeSocket *)ptr->data;
2857   ParameterList list;
2858   FunctionRNA *func;
2859
2860   if (!stemp->typeinfo) {
2861     return;
2862   }
2863
2864   func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2865
2866   RNA_parameter_list_create(&list, ptr, func);
2867   RNA_parameter_set_lookup(&list, "context", &C);
2868   RNA_parameter_set_lookup(&list, "layout", &layout);
2869   stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
2870
2871   RNA_parameter_list_free(&list);
2872 }
2873
2874 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
2875 {
2876   extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
2877
2878   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2879   ParameterList list;
2880   FunctionRNA *func;
2881   void *ret;
2882
2883   if (!sock->typeinfo) {
2884     return;
2885   }
2886
2887   func =
2888       &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2889
2890   RNA_parameter_list_create(&list, ptr, func);
2891   RNA_parameter_set_lookup(&list, "context", &C);
2892   sock->typeinfo->ext_interface.call(C, ptr, func, &list);
2893
2894   RNA_parameter_get_lookup(&list, "color", &ret);
2895   copy_v4_v4(r_color, (float *)ret);
2896
2897   RNA_parameter_list_free(&list);
2898 }
2899
2900 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree,
2901                                                         bNodeSocket *stemp,
2902                                                         StructRNA *data_srna)
2903 {
2904   extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
2905
2906   PointerRNA ptr;
2907   ParameterList list;
2908   FunctionRNA *func;
2909
2910   if (!stemp->typeinfo) {
2911     return;
2912   }
2913
2914   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2915   /* RNA_struct_find_function(&ptr, "register_properties"); */
2916   func = &rna_NodeSocketInterface_register_properties_func;
2917
2918   RNA_parameter_list_create(&list, &ptr, func);
2919   RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
2920   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2921
2922   RNA_parameter_list_free(&list);
2923 }
2924
2925 static void rna_NodeSocketInterface_init_socket(
2926     bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
2927 {
2928   extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
2929
2930   PointerRNA ptr, node_ptr, sock_ptr;
2931   ParameterList list;
2932   FunctionRNA *func;
2933
2934   if (!stemp->typeinfo) {
2935     return;
2936   }
2937
2938   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2939   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2940   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2941   /* RNA_struct_find_function(&ptr, "init_socket"); */
2942   func = &rna_NodeSocketInterface_init_socket_func;
2943
2944   RNA_parameter_list_create(&list, &ptr, func);
2945   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2946   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2947   RNA_parameter_set_lookup(&list, "data_path", &data_path);
2948   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2949
2950   RNA_parameter_list_free(&list);
2951 }
2952
2953 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree,
2954                                                 bNodeSocket *stemp,
2955                                                 bNode *node,
2956                                                 bNodeSocket *sock)
2957 {
2958   extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2959
2960   PointerRNA ptr, node_ptr, sock_ptr;
2961   ParameterList list;
2962   FunctionRNA *func;
2963
2964   if (!stemp->typeinfo) {
2965     return;
2966   }
2967
2968   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2969   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2970   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2971   /* RNA_struct_find_function(&ptr, "from_socket"); */
2972   func = &rna_NodeSocketInterface_from_socket_func;
2973
2974   RNA_parameter_list_create(&list, &ptr, func);
2975   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2976   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2977   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2978
2979   RNA_parameter_list_free(&list);
2980 }
2981
2982 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2983 {
2984   bNodeSocketType *st = RNA_struct_blender_type_get(type);
2985   if (!st) {
2986     return;
2987   }
2988
2989   RNA_struct_free_extension(type, &st->ext_interface);
2990
2991   RNA_struct_free(&BLENDER_RNA, type);
2992
2993   /* update while blender is running */
2994   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2995 }
2996
2997 static StructRNA *rna_NodeSocketInterface_register(Main *UNUSED(bmain),
2998                                                    ReportList *UNUSED(reports),
2999                                                    void *data,
3000                                                    const char *identifier,
3001                                                    StructValidateFunc validate,
3002                                                    StructCallbackFunc call,
3003                                                    StructFreeFunc free)
3004 {
3005   bNodeSocketType *st, dummyst;
3006   bNodeSocket dummysock;
3007   PointerRNA dummyptr;
3008   int have_function[5];
3009
3010   /* setup dummy socket & socket type to store static properties in */
3011   memset(&dummyst, 0, sizeof(bNodeSocketType));
3012
3013   memset(&dummysock, 0, sizeof(bNodeSocket));
3014   dummysock.typeinfo = &dummyst;
3015   RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
3016
3017   /* validate the python class */
3018   if (validate(&dummyptr, data, have_function) != 0) {
3019     return NULL;
3020   }
3021
3022   /* check if we have registered this socket type before */
3023   st = nodeSocketTypeFind(dummyst.idname);
3024   if (st) {
3025     /* basic socket type registered by a socket class before. */
3026   }
3027   else {
3028     /* create a new node socket type */
3029     st = MEM_mallocN(sizeof(bNodeSocketType), "node socket type");
3030     memcpy(st, &dummyst, sizeof(dummyst));
3031
3032     nodeRegisterSocketType(st);
3033   }
3034
3035   st->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
3036
3037   /* if RNA type is already registered, unregister first */
3038   if (st->ext_interface.srna) {
3039     StructRNA *srna = st->ext_interface.srna;
3040     RNA_struct_free_extension(srna, &st->ext_interface);
3041     RNA_struct_free(&BLENDER_RNA, srna);
3042   }
3043   st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface);
3044   st->ext_interface.data = data;
3045   st->ext_interface.call = call;
3046   st->ext_interface.free = free;
3047   RNA_struct_blender_type_set(st->ext_interface.srna, st);
3048
3049   st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
3050   st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
3051   st->interface_register_properties = (have_function[2]) ?
3052                                           rna_NodeSocketInterface_register_properties :
3053                                           NULL;
3054   st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
3055   st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
3056
3057   /* update while blender is running */
3058   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3059
3060   return st->ext_interface.srna;
3061 }
3062
3063 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
3064 {
3065   bNodeSocket *sock = (bNodeSocket *)ptr->data;
3066
3067   if (sock->typeinfo && sock->typeinfo->ext_interface.srna) {
3068     return sock->typeinfo->ext_interface.srna;
3069   }
3070   else {
3071     return &RNA_NodeSocketInterface;
3072   }
3073 }
3074
3075 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
3076 {
3077   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3078   bNodeSocket *sock = (bNodeSocket *)ptr->data;
3079   int socketindex;
3080
3081   socketindex = BLI_findindex(&ntree->inputs, sock);
3082   if (socketindex != -1) {
3083     return BLI_sprintfN("inputs[%d]", socketindex);
3084   }
3085
3086   socketindex = BLI_findindex(&ntree->outputs, sock);
3087   if (socketindex != -1) {
3088     return BLI_sprintfN("outputs[%d]", socketindex);
3089   }
3090
3091   return NULL;
3092 }
3093
3094 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
3095 {
3096   bNodeSocket *sock = ptr->data;
3097
3098   if (create && !sock->prop) {
3099     IDPropertyTemplate val = {0};
3100     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
3101   }
3102
3103   return sock->prop;
3104 }
3105
3106 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3107 {
3108   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3109   bNodeSocket *stemp = ptr->data;
3110
3111   if (!stemp->typeinfo) {
3112     return;
3113   }
3114
3115   ntree->update |= NTREE_UPDATE_GROUP;
3116   ntreeUpdateTree(bmain, ntree);
3117
3118   ED_node_tag_update_nodetree(bmain, ntree, NULL);
3119 }
3120
3121 /* ******** Standard Node Socket Base Types ******** */
3122
3123 static void rna_NodeSocketStandard_draw(ID *id,
3124                                         bNodeSocket *sock,
3125                                         struct bContext *C,
3126                                         struct uiLayout *layout,
3127                                         PointerRNA *nodeptr,
3128                                         const char *text)
3129 {
3130   PointerRNA ptr;
3131   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3132   sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
3133 }
3134
3135 static void rna_NodeSocketStandard_draw_color(
3136     ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
3137 {
3138   PointerRNA ptr;
3139   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3140   sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
3141 }
3142
3143 static void rna_NodeSocketInterfaceStandard_draw(ID *id,
3144                                                  bNodeSocket *sock,
3145                                                  struct bContext *C,
3146                                                  struct uiLayout *layout)
3147 {
3148   PointerRNA ptr;
3149   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3150   sock->typeinfo->interface_draw(C, layout, &ptr);
3151 }
3152
3153 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id,
3154                                                        bNodeSocket *sock,
3155                                                        struct bContext *C,
3156                                                        float *r_color)
3157 {
3158   PointerRNA ptr;
3159   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3160   sock->typeinfo->interface_draw_color(C, &ptr, r_color);
3161 }
3162
3163 static void rna_NodeSocketStandard_float_range(
3164     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3165 {
3166   bNodeSocket *sock = ptr->data;
3167   bNodeSocketValueFloat *dval = sock->default_value;
3168   int subtype = sock->typeinfo->subtype;
3169
3170   if (dval->max < dval->min) {
3171     dval->max = dval->min;
3172   }
3173
3174   *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
3175   *max = FLT_MAX;
3176   *softmin = dval->min;
3177   *softmax = dval->max;
3178 }
3179
3180 static void rna_NodeSocketStandard_int_range(
3181     PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
3182 {
3183   bNodeSocket *sock = ptr->data;
3184   bNodeSocketValueInt *dval = sock->default_value;
3185   int subtype = sock->typeinfo->subtype;
3186
3187   if (dval->max < dval->min) {
3188     dval->max = dval->min;
3189   }
3190
3191   *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
3192   *max = INT_MAX;
3193   *softmin = dval->min;
3194   *softmax = dval->max;
3195 }
3196
3197 static void rna_NodeSocketStandard_vector_range(
3198     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3199 {
3200   bNodeSocket *sock = ptr->data;
3201   bNodeSocketValueVector *dval = sock->default_value;
3202
3203   if (dval->max < dval->min) {
3204     dval->max = dval->min;
3205   }
3206
3207   *min = -FLT_MAX;
3208   *max = FLT_MAX;
3209   *softmin = dval->min;
3210   *softmax = dval->max;
3211 }
3212
3213 /* using a context update function here, to avoid searching the node if possible */
3214 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
3215 {
3216   bNode *node;
3217
3218   /* default update */
3219   rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
3220
3221   /* try to use node from context, faster */
3222   node = CTX_data_pointer_get(C, "node").data;
3223   if (!node) {
3224     bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3225     bNodeSocket *sock = ptr->data;
3226
3227     /* fall back to searching node in the tree */
3228     nodeFindNode(ntree, sock, &node, NULL);
3229   }
3230 }
3231
3232 static void rna_NodeSocketStandard_value_and_relation_update(struct bContext *C, PointerRNA *ptr)
3233 {
3234   rna_NodeSocketStandard_value_update(C, ptr);
3235   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3236   Main *bmain = CTX_data_main(C);
3237   ntreeUpdateTree(bmain, ntree);
3238   DEG_relations_tag_update(bmain);
3239 }
3240
3241 /* ******** Node Types ******** */
3242
3243 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
3244 {
3245   bNodeSocketTemplate *stemp = ptr->data;
3246   strcpy(value, stemp->name);
3247 }
3248
3249 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
3250 {
3251   bNodeSocketTemplate *stemp = ptr->data;
3252   return strlen(stemp->name);
3253 }
3254
3255 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
3256 {
3257   bNodeSocketTemplate *stemp = ptr->data;
3258   strcpy(value, stemp->identifier);
3259 }
3260
3261 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
3262 {
3263   bNodeSocketTemplate *stemp = ptr->data;
3264   return strlen(stemp->identifier);
3265 }
3266
3267 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
3268 {
3269   bNodeSocketTemplate *stemp = ptr->data;
3270   return stemp->type;
3271 }
3272
3273 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
3274 {
3275   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3276   if (ntype && ntype->inputs) {
3277     bNodeSocketTemplate *stemp = ntype->inputs;
3278     int i = 0;
3279     while (i < index && stemp->type >= 0) {
3280       i++;
3281       stemp++;
3282     }
3283     if (i == index && stemp->type >= 0) {
3284       PointerRNA ptr;
3285       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
3286       return ptr;
3287     }
3288   }
3289   return PointerRNA_NULL;
3290 }
3291
3292 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
3293 {
3294   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3295   if (ntype && ntype->outputs) {
3296     bNodeSocketTemplate *stemp = ntype->outputs;
3297     int i = 0;
3298     while (i < index && stemp->type >= 0) {
3299       i++;
3300       stemp++;
3301     }
3302     if (i == index && stemp->type >= 0) {
3303       PointerRNA ptr;
3304       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
3305       return ptr;
3306     }
3307   }
3308   return PointerRNA_NULL;
3309 }
3310
3311 static bool rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
3312 {
3313   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3314   const char *disabled_hint;
3315   return ntype && (!ntype->poll || ntype->poll(ntype, ntree, &disabled_hint));
3316 }
3317
3318 static bool rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
3319 {
3320   bNodeType *ntype = node->typeinfo;
3321   const char *disabled_hint;
3322   if (ntype->poll_instance) {
3323     return ntype->poll_instance(node, ntree, &disabled_hint);
3324   }
3325   else {
3326     /* fall back to basic poll function */
3327     return !ntype->poll || ntype->poll(ntype, ntree, &disabled_hint);
3328   }
3329 }
3330
3331 static void rna_NodeInternal_update(ID *id, bNode *node)
3332 {
3333   bNodeTree *ntree = (bNodeTree *)id;
3334   if (node->typeinfo->updatefunc) {
3335     node->typeinfo->updatefunc(ntree, node);
3336   }
3337 }
3338
3339 static void rna_NodeInternal_draw_buttons(ID *id,
3340                                           bNode *node,
3341                                           struct bContext *C,
3342                                           struct uiLayout *layout)
3343 {
3344   if (node->typeinfo->draw_buttons) {
3345     PointerRNA ptr;
3346     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3347     node->typeinfo->draw_buttons(layout, C, &ptr);
3348   }
3349 }
3350
3351 static void rna_NodeInternal_draw_buttons_ext(ID *id,
3352                                               bNode *node,
3353                                               struct bContext *C,
3354                                               struct uiLayout *layout)
3355 {
3356   if (node->typeinfo->draw_buttons_ex) {
3357     PointerRNA ptr;
3358     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3359     node->typeinfo->draw_buttons_ex(layout, C, &ptr);
3360   }
3361   else if (node->typeinfo->draw_buttons) {
3362     PointerRNA ptr;
3363     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3364     node->typeinfo->draw_buttons(layout, C, &ptr);
3365   }
3366 }
3367
3368 static StructRNA *rna_NodeCustomGroup_register(Main *bmain,
3369                                                ReportList *reports,
3370                                                void *data,
3371                                                const char *identifier,
3372                                                StructValidateFunc validate,
3373                                                StructCallbackFunc call,
3374                                                StructFreeFunc free)
3375 {
3376   bNodeType *nt = rna_Node_register_base(
3377       bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
3378   if (!nt) {
3379     return NULL;
3380   }
3381
3382   /* this updates the group node instance from the tree's interface */
3383   nt->group_update_func = node_group_update;
3384
3385   nodeRegisterType(nt);
3386
3387   /* update while blender is running */
3388   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3389
3390   return nt->rna_ext.srna;
3391 }
3392
3393 static StructRNA *rna_GeometryNodeCustomGroup_register(Main *bmain,
3394                                                        ReportList *reports,
3395                                                        void *data,
3396                                                        const char *identifier,
3397                                                        StructValidateFunc validate,
3398                                                        StructCallbackFunc call,
3399                                                        StructFreeFunc free)
3400 {
3401   bNodeType *nt = rna_Node_register_base(
3402       bmain, reports, &RNA_GeometryNodeCustomGroup, data, identifier, validate, call, free);
3403
3404   if (!nt) {
3405     return NULL;
3406   }
3407
3408   nt->group_update_func = node_group_update;
3409   nt->type = NODE_CUSTOM_GROUP;
3410
3411   register_node_type_geo_custom_group(nt);
3412
3413   nodeRegisterType(nt);
3414
3415   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3416
3417   return nt->rna_ext.srna;
3418 }
3419
3420 void register_node_type_geo_custom_group(bNodeType *ntype);
3421
3422 static StructRNA *rna_ShaderNodeCustomGroup_register(Main *bmain,
3423                                                      ReportList *reports,
3424                                                      void *data,
3425                                                      const char *identifier,
3426                                                      StructValidateFunc validate,
3427                                                      StructCallbackFunc call,
3428                                                      StructFreeFunc free)
3429 {
3430   bNodeType *nt = rna_Node_register_base(
3431       bmain, reports, &RNA_ShaderNodeCustomGroup, data, identifier, validate, call, free);
3432
3433   if (!nt) {
3434     return NULL;
3435   }
3436
3437   nt->group_update_func = node_group_update;
3438   nt->type = NODE_CUSTOM_GROUP;
3439
3440   register_node_type_sh_custom_group(nt);
3441
3442   nodeRegisterType(nt);
3443
3444   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3445
3446   return nt->rna_ext.srna;
3447 }
3448
3449 static StructRNA *rna_CompositorNodeCustomGroup_register(Main *bmain,
3450                                                          ReportList *reports,
3451                                                          void *data,
3452                                                          const char *identifier,
3453                                                          StructValidateFunc validate,
3454                                                          StructCallbackFunc call,
3455                                                          StructFreeFunc free)
3456 {
3457   bNodeType *nt = rna_Node_register_base(
3458       bmain, reports, &RNA_CompositorNodeCustomGroup, data, identifier, validate, call, free);
3459   if (!nt) {
3460     return NULL;
3461   }
3462
3463   nt->group_update_func = node_group_update;
3464   nt->type = NODE_CUSTOM_GROUP;
3465
3466   register_node_type_cmp_custom_group(nt);
3467
3468   nodeRegisterType(nt);
3469
3470   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3471
3472   return nt->rna_ext.srna;
3473 }
3474
3475 static void rna_CompositorNode_tag_need_exec(bNode *node)
3476 {
3477   node->need_exec = true;
3478 }
3479
3480 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3481 {
3482   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3483   bNode *node = (bNode *)ptr->data;
3484
3485   ED_node_tag_update_nodetree(bmain, ntree, node);
3486   WM_main_add_notifier(NC_IMAGE, NULL);
3487 }
3488
3489 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3490 {
3491   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3492   bNode *node = (bNode *)ptr->data;
3493
3494   if (node->id) {
3495     ntreeUpdateTree(bmain, (bNodeTree *)node->id);
3496   }
3497
3498   ED_node_tag_update_nodetree(bmain, ntree, node);
3499   DEG_relations_tag_update(bmain);
3500 }
3501
3502 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr,
3503                                         const PointerRNA value,
3504                                         struct ReportList *UNUSED(reports))
3505 {
3506   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3507   bNode *node = ptr->data;
3508   bNodeTree *ngroup = value.data;
3509
3510   const char *disabled_hint = NULL;
3511   if (nodeGroupPoll(ntree, ngroup, &disabled_hint)) {
3512     if (node->id) {
3513       id_us_min(node->id);
3514     }
3515     if (ngroup) {
3516       id_us_plus(&ngroup->id);
3517     }
3518
3519     node->id = &ngroup->id;
3520   }
3521 }
3522
3523 static bool rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
3524 {
3525   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3526   bNodeTree *ngroup = value.data;
3527
3528   /* only allow node trees of the same type as the group node's tree */
3529   if (ngroup->type != ntree->type) {
3530     return false;
3531   }
3532
3533   const char *disabled_hint = NULL;
3534   return nodeGroupPoll(ntree, ngroup, &disabled_hint);
3535 }
3536
3537 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
3538 {
3539   bNode *node = ptr->data;
3540   bNodeTree *ngroup = (bNodeTree *)node->id;
3541
3542   if (ngroup) {
3543     StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
3544     if (srna) {
3545       return srna;
3546     }
3547   }
3548   return &RNA_PropertyGroup;
3549 }
3550
3551 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
3552 {
3553   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3554
3555   if (ntree) {
3556     StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
3557     if (srna) {
3558       return srna;
3559     }
3560   }
3561   return &RNA_PropertyGroup;
3562 }
3563
3564 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
3565 {
3566   bNode *node = (bNode *)ptr->data;
3567   NodeChroma *chroma = node->storage;
3568
3569   chroma->t1 = value;
3570 }
3571
3572 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
3573 {
3574   bNode *node = (bNode *)ptr->data;
3575   NodeChroma *chroma = node->storage;
3576
3577   chroma->t2 = value;
3578 }
3579
3580 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
3581 {
3582   bNode *node = (bNode *)ptr->data;
3583   NodeChroma *chroma = node->storage;
3584
3585   chroma->t1 = value;
3586 }
3587
3588 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
3589 {
3590   bNode *node = (bNode *)ptr->data;
3591   NodeChroma *chroma = node->storage;
3592
3593   chroma->t2 = value;
3594 }
3595
3596 /* Button Set Funcs for Matte Nodes */
3597 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
3598 {
3599   bNode *node = (bNode *)ptr->data;
3600   NodeChroma *chroma = node->storage;
3601
3602   chroma->t1 = value;
3603
3604   if (value < chroma->t2) {
3605     chroma->t2 = value;
3606   }
3607 }
3608
3609 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
3610 {
3611   bNode *node = (bNode *)ptr->data;
3612   NodeChroma *chroma = node->storage;
3613
3614   if (value > chroma->t1) {
3615     value = chroma->t1;
3616   }
3617
3618   chroma->t2 = value;
3619 }
3620
3621 static void rna_Node_scene_set(PointerRNA *ptr,
3622                                PointerRNA value,
3623                                struct ReportList *UNUSED(reports))
3624 {
3625   bNode *node = (bNode *)ptr->data;
3626
3627   if (node->id) {
3628     id_us_min(node->id);
3629     node->id = NULL;
3630   }
3631
3632   node->id = value.data;
3633
3634   id_us_plus(node->id);
3635 }
3636
3637 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3638 {
3639   bNode *node = (bNode *)ptr->data;
3640   Image *ima = (Image *)node->id;
3641   ImageUser *iuser = node->storage;
3642
3643   if (node->type == CMP_NODE_CRYPTOMATTE && node->custom1 != CMP_CRYPTOMATTE_SRC_IMAGE) {
3644     return;
3645   }
3646
3647   BKE_image_multilayer_index(ima->rr, iuser);
3648   BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_SRC_CHANGE);
3649
3650   rna_Node_update(bmain, scene, ptr);
3651
3652   if (scene->nodetree != NULL) {
3653     ntreeCompositUpdateRLayers(scene->nodetree);
3654   }
3655 }
3656
3657 static const EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
3658 {
3659   EnumPropertyItem *item = NULL;
3660   EnumPropertyItem tmp = {0};