Merge branch 'blender-v2.93-release'
[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     DEG_id_tag_update(&ntree->id, 0);
1427     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1428   }
1429 }
1430
1431 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1432 {
1433   if (!rna_NodeTree_check(ntree, reports)) {
1434     return;
1435   }
1436
1437   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, socket, &ntree->inputs) {
1438     ntreeRemoveSocketInterface(ntree, socket);
1439   }
1440
1441   ntreeUpdateTree(bmain, ntree);
1442   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1443 }
1444
1445 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1446 {
1447   if (!rna_NodeTree_check(ntree, reports)) {
1448     return;
1449   }
1450
1451   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, socket, &ntree->outputs) {
1452     ntreeRemoveSocketInterface(ntree, socket);
1453   }
1454
1455   ntreeUpdateTree(bmain, ntree);
1456   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1457 }
1458
1459 static void rna_NodeTree_inputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1460 {
1461   if (from_index == to_index) {
1462     return;
1463   }
1464   if (from_index < 0 || to_index < 0) {
1465     return;
1466   }
1467
1468   bNodeSocket *sock = BLI_findlink(&ntree->inputs, from_index);
1469   if (to_index < from_index) {
1470     bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
1471     if (nextsock) {
1472       BLI_remlink(&ntree->inputs, sock);
1473       BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
1474     }
1475   }
1476   else {
1477     bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
1478     if (prevsock) {
1479       BLI_remlink(&ntree->inputs, sock);
1480       BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1481     }
1482   }
1483
1484   ntree->update |= NTREE_UPDATE_GROUP_IN;
1485
1486   ntreeUpdateTree(bmain, ntree);
1487   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1488 }
1489
1490 static void rna_NodeTree_outputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1491 {
1492   if (from_index == to_index) {
1493     return;
1494   }
1495   if (from_index < 0 || to_index < 0) {
1496     return;
1497   }
1498
1499   bNodeSocket *sock = BLI_findlink(&ntree->outputs, from_index);
1500   if (to_index < from_index) {
1501     bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1502     if (nextsock) {
1503       BLI_remlink(&ntree->outputs, sock);
1504       BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1505     }
1506   }
1507   else {
1508     bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1509     if (prevsock) {
1510       BLI_remlink(&ntree->outputs, sock);
1511       BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1512     }
1513   }
1514
1515   ntree->update |= NTREE_UPDATE_GROUP_OUT;
1516
1517   ntreeUpdateTree(bmain, ntree);
1518   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1519 }
1520
1521 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1522 {
1523   Main *bmain = CTX_data_main(C);
1524
1525   ntree->update |= NTREE_UPDATE_GROUP;
1526   ntreeUpdateTree(bmain, ntree);
1527
1528   ED_node_tag_update_nodetree(bmain, ntree, NULL);
1529 }
1530
1531 /* ******** NodeLink ******** */
1532
1533 static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1534 {
1535   bNodeLink *link = ptr->data;
1536   return nodeLinkIsHidden(link);
1537 }
1538
1539 /* ******** Node ******** */
1540
1541 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1542 {
1543   bNode *node = (bNode *)ptr->data;
1544
1545   if (node->typeinfo->rna_ext.srna) {
1546     return node->typeinfo->rna_ext.srna;
1547   }
1548   else {
1549     return ptr->type;
1550   }
1551 }
1552
1553 static char *rna_Node_path(PointerRNA *ptr)
1554 {
1555   bNode *node = (bNode *)ptr->data;
1556   char name_esc[sizeof(node->name) * 2];
1557
1558   BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1559   return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1560 }
1561
1562 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1563 {
1564   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
1565   bNode *node;
1566   char name_esc[sizeof(node->name) * 2];
1567
1568   for (node = ntree->nodes.first; node; node = node->next) {
1569     if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1570       NodeTexEnvironment *data = node->storage;
1571       if (&data->iuser != ptr->data) {
1572         continue;
1573       }
1574     }
1575     else if (node->type == SH_NODE_TEX_IMAGE) {
1576       NodeTexImage *data = node->storage;
1577       if (&data->iuser != ptr->data) {
1578         continue;
1579       }
1580     }
1581     else {
1582       continue;
1583     }
1584
1585     BLI_str_escape(name_esc, node->name, sizeof(name_esc));
1586     return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1587   }
1588
1589   return NULL;
1590 }
1591
1592 static bool rna_Node_poll(bNodeType *ntype, bNodeTree *ntree, const char **UNUSED(r_disabled_hint))
1593 {
1594   extern FunctionRNA rna_Node_poll_func;
1595
1596   PointerRNA ptr;
1597   ParameterList list;
1598   FunctionRNA *func;
1599   void *ret;
1600   bool visible;
1601
1602   RNA_pointer_create(NULL, ntype->rna_ext.srna, NULL, &ptr); /* dummy */
1603   func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1604
1605   RNA_parameter_list_create(&list, &ptr, func);
1606   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1607   ntype->rna_ext.call(NULL, &ptr, func, &list);
1608
1609   RNA_parameter_get_lookup(&list, "visible", &ret);
1610   visible = *(bool *)ret;
1611
1612   RNA_parameter_list_free(&list);
1613
1614   return visible;
1615 }
1616
1617 static bool rna_Node_poll_instance(bNode *node,
1618                                    bNodeTree *ntree,
1619                                    const char **UNUSED(disabled_info))
1620 {
1621   extern FunctionRNA rna_Node_poll_instance_func;
1622
1623   PointerRNA ptr;
1624   ParameterList list;
1625   FunctionRNA *func;
1626   void *ret;
1627   bool visible;
1628
1629   RNA_pointer_create(NULL, node->typeinfo->rna_ext.srna, node, &ptr); /* dummy */
1630   func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1631
1632   RNA_parameter_list_create(&list, &ptr, func);
1633   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1634   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1635
1636   RNA_parameter_get_lookup(&list, "visible", &ret);
1637   visible = *(bool *)ret;
1638
1639   RNA_parameter_list_free(&list);
1640
1641   return visible;
1642 }
1643
1644 static bool rna_Node_poll_instance_default(bNode *node,
1645                                            bNodeTree *ntree,
1646                                            const char **disabled_info)
1647 {
1648   /* use the basic poll function */
1649   return rna_Node_poll(node->typeinfo, ntree, disabled_info);
1650 }
1651
1652 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1653 {
1654   extern FunctionRNA rna_Node_update_func;
1655
1656   PointerRNA ptr;
1657   ParameterList list;
1658   FunctionRNA *func;
1659
1660   RNA_pointer_create((ID *)ntree, node->typeinfo->rna_ext.srna, node, &ptr);
1661   func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1662
1663   RNA_parameter_list_create(&list, &ptr, func);
1664   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1665
1666   RNA_parameter_list_free(&list);
1667 }
1668
1669 static void rna_Node_insert_link(bNodeTree *ntree, bNode *node, bNodeLink *link)
1670 {
1671   extern FunctionRNA rna_Node_insert_link_func;
1672
1673   PointerRNA ptr;
1674   ParameterList list;
1675   FunctionRNA *func;
1676
1677   RNA_pointer_create((ID *)ntree, node->typeinfo->rna_ext.srna, node, &ptr);
1678   func = &rna_Node_insert_link_func;
1679
1680   RNA_parameter_list_create(&list, &ptr, func);
1681   RNA_parameter_set_lookup(&list, "link", &link);
1682   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1683
1684   RNA_parameter_list_free(&list);
1685 }
1686
1687 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1688 {
1689   extern FunctionRNA rna_Node_init_func;
1690
1691   bNode *node = (bNode *)ptr->data;
1692   ParameterList list;
1693   FunctionRNA *func;
1694
1695   func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1696
1697   RNA_parameter_list_create(&list, ptr, func);
1698   node->typeinfo->rna_ext.call((bContext *)C, ptr, func, &list);
1699
1700   RNA_parameter_list_free(&list);
1701 }
1702
1703 static void rna_Node_copy(PointerRNA *ptr, const struct bNode *copynode)
1704 {
1705   extern FunctionRNA rna_Node_copy_func;
1706
1707   bNode *node = (bNode *)ptr->data;
1708   ParameterList list;
1709   FunctionRNA *func;
1710
1711   func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1712
1713   RNA_parameter_list_create(&list, ptr, func);
1714   RNA_parameter_set_lookup(&list, "node", &copynode);
1715   node->typeinfo->rna_ext.call(NULL, ptr, func, &list);
1716
1717   RNA_parameter_list_free(&list);
1718 }
1719
1720 static void rna_Node_free(PointerRNA *ptr)
1721 {
1722   extern FunctionRNA rna_Node_free_func;
1723
1724   bNode *node = (bNode *)ptr->data;
1725   ParameterList list;
1726   FunctionRNA *func;
1727
1728   func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1729
1730   RNA_parameter_list_create(&list, ptr, func);
1731   node->typeinfo->rna_ext.call(NULL, ptr, func, &list);
1732
1733   RNA_parameter_list_free(&list);
1734 }
1735
1736 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1737 {
1738   extern FunctionRNA rna_Node_draw_buttons_func;
1739
1740   bNode *node = (bNode *)ptr->data;
1741   ParameterList list;
1742   FunctionRNA *func;
1743
1744   func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1745
1746   RNA_parameter_list_create(&list, ptr, func);
1747   RNA_parameter_set_lookup(&list, "context", &C);
1748   RNA_parameter_set_lookup(&list, "layout", &layout);
1749   node->typeinfo->rna_ext.call(C, ptr, func, &list);
1750
1751   RNA_parameter_list_free(&list);
1752 }
1753
1754 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1755 {
1756   extern FunctionRNA rna_Node_draw_buttons_ext_func;
1757
1758   bNode *node = (bNode *)ptr->data;
1759   ParameterList list;
1760   FunctionRNA *func;
1761
1762   func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1763
1764   RNA_parameter_list_create(&list, ptr, func);
1765   RNA_parameter_set_lookup(&list, "context", &C);
1766   RNA_parameter_set_lookup(&list, "layout", &layout);
1767   node->typeinfo->rna_ext.call(C, ptr, func, &list);
1768
1769   RNA_parameter_list_free(&list);
1770 }
1771
1772 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1773 {
1774   extern FunctionRNA rna_Node_draw_label_func;
1775
1776   PointerRNA ptr;
1777   ParameterList list;
1778   FunctionRNA *func;
1779   void *ret;
1780   char *rlabel;
1781
1782   func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1783
1784   RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1785   RNA_parameter_list_create(&list, &ptr, func);
1786   node->typeinfo->rna_ext.call(NULL, &ptr, func, &list);
1787
1788   RNA_parameter_get_lookup(&list, "label", &ret);
1789   rlabel = (char *)ret;
1790   BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1791
1792   RNA_parameter_list_free(&list);
1793 }
1794
1795 static bool rna_Node_is_registered_node_type(StructRNA *type)
1796 {
1797   return (RNA_struct_blender_type_get(type) != NULL);
1798 }
1799
1800 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C),
1801                                                      ReportList *UNUSED(reports),
1802                                                      PointerRNA *ptr,
1803                                                      ParameterList *parms)
1804 {
1805   int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1806   RNA_parameter_set_lookup(parms, "result", &result);
1807 }
1808
1809 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1810 {
1811   bNodeType *nt = RNA_struct_blender_type_get(type);
1812
1813   if (!nt) {
1814     return;
1815   }
1816
1817   RNA_struct_free_extension(type, &nt->rna_ext);
1818   RNA_struct_free(&BLENDER_RNA, type);
1819
1820   /* this also frees the allocated nt pointer, no MEM_free call needed! */
1821   nodeUnregisterType(nt);
1822
1823   /* update while blender is running */
1824   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1825 }
1826
1827 /* Generic internal registration function.
1828  * Can be used to implement callbacks for registerable RNA node subtypes.
1829  */
1830 static bNodeType *rna_Node_register_base(Main *bmain,
1831                                          ReportList *reports,
1832                                          StructRNA *basetype,
1833                                          void *data,
1834                                          const char *identifier,
1835                                          StructValidateFunc validate,
1836                                          StructCallbackFunc call,
1837                                          StructFreeFunc free)
1838 {
1839   bNodeType *nt, dummynt;
1840   bNode dummynode;
1841   PointerRNA dummyptr;
1842   FunctionRNA *func;
1843   PropertyRNA *parm;
1844   int have_function[10];
1845
1846   /* setup dummy node & node type to store static properties in */
1847   memset(&dummynt, 0, sizeof(bNodeType));
1848   /* this does some additional initialization of default values */
1849   node_type_base_custom(&dummynt, identifier, "", 0, 0);
1850
1851   memset(&dummynode, 0, sizeof(bNode));
1852   dummynode.typeinfo = &dummynt;
1853   RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1854
1855   /* validate the python class */
1856   if (validate(&dummyptr, data, have_function) != 0) {
1857     return NULL;
1858   }
1859
1860   if (strlen(identifier) >= sizeof(dummynt.idname)) {
1861     BKE_reportf(reports,
1862                 RPT_ERROR,
1863                 "Registering node class: '%s' is too long, maximum length is %d",
1864                 identifier,
1865                 (int)sizeof(dummynt.idname));
1866     return NULL;
1867   }
1868
1869   /* check if we have registered this node type before, and remove it */
1870   nt = nodeTypeFind(dummynt.idname);
1871   if (nt) {
1872     rna_Node_unregister(bmain, nt->rna_ext.srna);
1873   }
1874
1875   /* create a new node type */
1876   nt = MEM_mallocN(sizeof(bNodeType), "node type");
1877   memcpy(nt, &dummynt, sizeof(dummynt));
1878   nt->free_self = (void (*)(bNodeType *))MEM_freeN;
1879
1880   nt->rna_ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1881   nt->rna_ext.data = data;
1882   nt->rna_ext.call = call;
1883   nt->rna_ext.free = free;
1884   RNA_struct_blender_type_set(nt->rna_ext.srna, nt);
1885
1886   RNA_def_struct_ui_text(nt->rna_ext.srna, nt->ui_name, nt->ui_description);
1887   RNA_def_struct_ui_icon(nt->rna_ext.srna, nt->ui_icon);
1888
1889   func = RNA_def_function_runtime(
1890       nt->rna_ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1891   RNA_def_function_ui_description(func, "True if a registered node type");
1892   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1893   parm = RNA_def_boolean(func, "result", false, "Result", "");
1894   RNA_def_function_return(func, parm);
1895
1896   /* XXX bad level call! needed to initialize the basic draw functions ... */
1897   ED_init_custom_node_type(nt);
1898
1899   nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1900   nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1901   nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1902   nt->insert_link = (have_function[3]) ? rna_Node_insert_link : NULL;
1903   nt->initfunc_api = (have_function[4]) ? rna_Node_init : NULL;
1904   nt->copyfunc_api = (have_function[5]) ? rna_Node_copy : NULL;
1905   nt->freefunc_api = (have_function[6]) ? rna_Node_free : NULL;
1906   nt->draw_buttons = (have_function[7]) ? rna_Node_draw_buttons : NULL;
1907   nt->draw_buttons_ex = (have_function[8]) ? rna_Node_draw_buttons_ext : NULL;
1908   nt->labelfunc = (have_function[9]) ? rna_Node_draw_label : NULL;
1909
1910   /* sanitize size values in case not all have been registered */
1911   if (nt->maxwidth < nt->minwidth) {
1912     nt->maxwidth = nt->minwidth;
1913   }
1914   if (nt->maxheight < nt->minheight) {
1915     nt->maxheight = nt->minheight;
1916   }
1917   CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1918   CLAMP(nt->height, nt->minheight, nt->maxheight);
1919
1920   return nt;
1921 }
1922
1923 static StructRNA *rna_Node_register(Main *bmain,
1924                                     ReportList *reports,
1925                                     void *data,
1926                                     const char *identifier,
1927                                     StructValidateFunc validate,
1928                                     StructCallbackFunc call,
1929                                     StructFreeFunc free)
1930 {
1931   bNodeType *nt = rna_Node_register_base(
1932       bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1933   if (!nt) {
1934     return NULL;
1935   }
1936
1937   nodeRegisterType(nt);
1938
1939   /* update while blender is running */
1940   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1941
1942   return nt->rna_ext.srna;
1943 }
1944
1945 static const EnumPropertyItem *itemf_function_check(
1946     const EnumPropertyItem *original_item_array,
1947     bool (*value_supported)(const EnumPropertyItem *item))
1948 {
1949   EnumPropertyItem *item_array = NULL;
1950   int items_len = 0;
1951
1952   for (const EnumPropertyItem *item = original_item_array; item->identifier != NULL; item++) {
1953     if (value_supported(item)) {
1954       RNA_enum_item_add(&item_array, &items_len, item);
1955     }
1956   }
1957
1958   RNA_enum_item_end(&item_array, &items_len);
1959   return item_array;
1960 }
1961
1962 static bool switch_type_supported(const EnumPropertyItem *item)
1963 {
1964   return ELEM(item->value,
1965               SOCK_FLOAT,
1966               SOCK_INT,
1967               SOCK_BOOLEAN,
1968               SOCK_VECTOR,
1969               SOCK_STRING,
1970               SOCK_RGBA,
1971               SOCK_GEOMETRY,
1972               SOCK_OBJECT,
1973               SOCK_COLLECTION);
1974 }
1975
1976 static const EnumPropertyItem *rna_GeometryNodeSwitch_type_itemf(bContext *UNUSED(C),
1977                                                                  PointerRNA *UNUSED(ptr),
1978                                                                  PropertyRNA *UNUSED(prop),
1979                                                                  bool *r_free)
1980 {
1981   *r_free = true;
1982   return itemf_function_check(node_socket_data_type_items, switch_type_supported);
1983 }
1984
1985 static bool attribute_clamp_type_supported(const EnumPropertyItem *item)
1986 {
1987   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_INT32, CD_PROP_COLOR);
1988 }
1989 static const EnumPropertyItem *rna_GeometryNodeAttributeClamp_type_itemf(bContext *UNUSED(C),
1990                                                                          PointerRNA *UNUSED(ptr),
1991                                                                          PropertyRNA *UNUSED(prop),
1992                                                                          bool *r_free)
1993 {
1994   *r_free = true;
1995   return itemf_function_check(rna_enum_attribute_type_items, attribute_clamp_type_supported);
1996 }
1997
1998 static bool attribute_random_type_supported(const EnumPropertyItem *item)
1999 {
2000   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_BOOL, CD_PROP_INT32);
2001 }
2002 static const EnumPropertyItem *rna_GeometryNodeAttributeRandom_type_itemf(
2003     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2004 {
2005   *r_free = true;
2006   return itemf_function_check(rna_enum_attribute_type_items, attribute_random_type_supported);
2007 }
2008
2009 static const EnumPropertyItem *rna_GeometryNodeAttributeRandomize_operation_itemf(
2010     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2011 {
2012   bNode *node = ptr->data;
2013   const NodeAttributeRandomize *node_storage = (NodeAttributeRandomize *)node->storage;
2014   const CustomDataType data_type = (CustomDataType)node_storage->data_type;
2015
2016   EnumPropertyItem *item_array = NULL;
2017   int items_len = 0;
2018   for (const EnumPropertyItem *item = rna_node_geometry_attribute_randomize_operation_items;
2019        item->identifier != NULL;
2020        item++) {
2021     if (data_type == CD_PROP_BOOL) {
2022       if (item->value == GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE) {
2023         RNA_enum_item_add(&item_array, &items_len, item);
2024       }
2025     }
2026     else {
2027       RNA_enum_item_add(&item_array, &items_len, item);
2028     }
2029   }
2030   RNA_enum_item_end(&item_array, &items_len);
2031
2032   *r_free = true;
2033   return item_array;
2034 }
2035
2036 static void rna_GeometryNodeAttributeRandomize_data_type_update(Main *bmain,
2037                                                                 Scene *scene,
2038                                                                 PointerRNA *ptr)
2039 {
2040   bNode *node = ptr->data;
2041   NodeAttributeRandomize *node_storage = (NodeAttributeRandomize *)node->storage;
2042
2043   /* The boolean data type has no extra operations besides,
2044    * replace, so make sure the enum value is set properly. */
2045   if (node_storage->data_type == CD_PROP_BOOL) {
2046     node_storage->operation = GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE;
2047   }
2048
2049   rna_Node_socket_update(bmain, scene, ptr);
2050 }
2051
2052 static bool attribute_convert_type_supported(const EnumPropertyItem *item)
2053 {
2054   return ELEM(item->value,
2055               CD_AUTO_FROM_NAME,
2056               CD_PROP_FLOAT,
2057               CD_PROP_FLOAT2,
2058               CD_PROP_FLOAT3,
2059               CD_PROP_COLOR,
2060               CD_PROP_BOOL,
2061               CD_PROP_INT32);
2062 }
2063 static const EnumPropertyItem *rna_GeometryNodeAttributeConvert_type_itemf(
2064     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2065 {
2066   *r_free = true;
2067   return itemf_function_check(rna_enum_attribute_type_with_auto_items,
2068                               attribute_convert_type_supported);
2069 }
2070
2071 static bool attribute_fill_type_supported(const EnumPropertyItem *item)
2072 {
2073   return ELEM(
2074       item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_COLOR, CD_PROP_BOOL, CD_PROP_INT32);
2075 }
2076 static const EnumPropertyItem *rna_GeometryNodeAttributeFill_type_itemf(bContext *UNUSED(C),
2077                                                                         PointerRNA *UNUSED(ptr),
2078                                                                         PropertyRNA *UNUSED(prop),
2079                                                                         bool *r_free)
2080 {
2081   *r_free = true;
2082   return itemf_function_check(rna_enum_attribute_type_items, attribute_fill_type_supported);
2083 }
2084
2085 /**
2086  * This bit of ugly code makes sure the float / attribute option shows up instead of
2087  * vector / attribute if the node uses an operation that uses a float for input B or C.
2088  */
2089 static const EnumPropertyItem *rna_GeometryNodeAttributeVectorMath_input_type_b_itemf(
2090     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2091 {
2092   bNode *node = ptr->data;
2093   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2094
2095   EnumPropertyItem *item_array = NULL;
2096   int items_len = 0;
2097   for (const EnumPropertyItem *item = rna_node_geometry_attribute_input_type_items_any;
2098        item->identifier != NULL;
2099        item++) {
2100     if (item->value == GEO_NODE_ATTRIBUTE_INPUT_ATTRIBUTE) {
2101       RNA_enum_item_add(&item_array, &items_len, item);
2102     }
2103     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2104       if (node_storage->operation == NODE_VECTOR_MATH_SCALE) {
2105         RNA_enum_item_add(&item_array, &items_len, item);
2106       }
2107     }
2108     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2109       if (node_storage->operation != NODE_VECTOR_MATH_SCALE) {
2110         RNA_enum_item_add(&item_array, &items_len, item);
2111       }
2112     }
2113   }
2114   RNA_enum_item_end(&item_array, &items_len);
2115
2116   *r_free = true;
2117   return item_array;
2118 }
2119
2120 static const EnumPropertyItem *rna_GeometryNodeAttributeVectorMath_input_type_c_itemf(
2121     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
2122 {
2123   bNode *node = ptr->data;
2124   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2125
2126   EnumPropertyItem *item_array = NULL;
2127   int items_len = 0;
2128   for (const EnumPropertyItem *item = rna_node_geometry_attribute_input_type_items_any;
2129        item->identifier != NULL;
2130        item++) {
2131     if (item->value == GEO_NODE_ATTRIBUTE_INPUT_ATTRIBUTE) {
2132       RNA_enum_item_add(&item_array, &items_len, item);
2133     }
2134     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2135       if (node_storage->operation == NODE_VECTOR_MATH_REFRACT) {
2136         RNA_enum_item_add(&item_array, &items_len, item);
2137       }
2138     }
2139     else if (item->value == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2140       if (node_storage->operation != NODE_VECTOR_MATH_REFRACT) {
2141         RNA_enum_item_add(&item_array, &items_len, item);
2142       }
2143     }
2144   }
2145   RNA_enum_item_end(&item_array, &items_len);
2146
2147   *r_free = true;
2148   return item_array;
2149 }
2150
2151 static void rna_GeometryNodeAttributeVectorMath_operation_update(Main *bmain,
2152                                                                  Scene *scene,
2153                                                                  PointerRNA *ptr)
2154 {
2155   bNode *node = ptr->data;
2156   NodeAttributeVectorMath *node_storage = (NodeAttributeVectorMath *)node->storage;
2157
2158   const NodeVectorMathOperation operation = (NodeVectorMathOperation)node_storage->operation;
2159
2160   /* The scale operation can't use a vector input, so reset
2161    * the input type enum in case it's set to vector. */
2162   if (operation == NODE_VECTOR_MATH_SCALE) {
2163     if (node_storage->input_type_b == GEO_NODE_ATTRIBUTE_INPUT_VECTOR) {
2164       node_storage->input_type_b = GEO_NODE_ATTRIBUTE_INPUT_FLOAT;
2165     }
2166   }
2167
2168   /* Scale is also the only operation that uses the float input type, so a
2169    * a check is also necessary for the other direction. */
2170   if (operation != NODE_VECTOR_MATH_SCALE) {
2171     if (node_storage->input_type_b == GEO_NODE_ATTRIBUTE_INPUT_FLOAT) {
2172       node_storage->input_type_b = GEO_NODE_ATTRIBUTE_INPUT_VECTOR;
2173     }
2174   }
2175
2176   rna_Node_socket_update(bmain, scene, ptr);
2177 }
2178
2179 static bool attribute_map_range_type_supported(const EnumPropertyItem *item)
2180 {
2181   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3);
2182 }
2183 static const EnumPropertyItem *rna_GeometryNodeAttributeMapRange_type_itemf(
2184     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2185 {
2186   *r_free = true;
2187   return itemf_function_check(rna_enum_attribute_type_items, attribute_map_range_type_supported);
2188 }
2189
2190 static bool attribute_curve_map_type_supported(const EnumPropertyItem *item)
2191 {
2192   return ELEM(item->value, CD_PROP_FLOAT, CD_PROP_FLOAT3, CD_PROP_COLOR);
2193 }
2194 static const EnumPropertyItem *rna_GeometryNodeAttributeCurveMap_type_itemf(
2195     bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2196 {
2197   *r_free = true;
2198   return itemf_function_check(rna_enum_attribute_type_items, attribute_curve_map_type_supported);
2199 }
2200
2201 static StructRNA *rna_ShaderNode_register(Main *bmain,
2202                                           ReportList *reports,
2203                                           void *data,
2204                                           const char *identifier,
2205                                           StructValidateFunc validate,
2206                                           StructCallbackFunc call,
2207                                           StructFreeFunc free)
2208 {
2209   bNodeType *nt = rna_Node_register_base(
2210       bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
2211   if (!nt) {
2212     return NULL;
2213   }
2214
2215   nodeRegisterType(nt);
2216
2217   /* update while blender is running */
2218   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2219
2220   return nt->rna_ext.srna;
2221 }
2222
2223 static StructRNA *rna_CompositorNode_register(Main *bmain,
2224                                               ReportList *reports,
2225                                               void *data,
2226                                               const char *identifier,
2227                                               StructValidateFunc validate,
2228                                               StructCallbackFunc call,
2229                                               StructFreeFunc free)
2230 {
2231   bNodeType *nt = rna_Node_register_base(
2232       bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
2233   if (!nt) {
2234     return NULL;
2235   }
2236
2237   nodeRegisterType(nt);
2238
2239   /* update while blender is running */
2240   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2241
2242   return nt->rna_ext.srna;
2243 }
2244
2245 static StructRNA *rna_TextureNode_register(Main *bmain,
2246                                            ReportList *reports,
2247                                            void *data,
2248                                            const char *identifier,
2249                                            StructValidateFunc validate,
2250                                            StructCallbackFunc call,
2251                                            StructFreeFunc free)
2252 {
2253   bNodeType *nt = rna_Node_register_base(
2254       bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
2255   if (!nt) {
2256     return NULL;
2257   }
2258
2259   nodeRegisterType(nt);
2260
2261   /* update while blender is running */
2262   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2263
2264   return nt->rna_ext.srna;
2265 }
2266
2267 static StructRNA *rna_GeometryNode_register(Main *bmain,
2268                                             ReportList *reports,
2269                                             void *data,
2270                                             const char *identifier,
2271                                             StructValidateFunc validate,
2272                                             StructCallbackFunc call,
2273                                             StructFreeFunc free)
2274 {
2275   bNodeType *nt = rna_Node_register_base(
2276       bmain, reports, &RNA_GeometryNode, data, identifier, validate, call, free);
2277   if (!nt) {
2278     return NULL;
2279   }
2280
2281   nodeRegisterType(nt);
2282
2283   /* update while blender is running */
2284   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2285
2286   return nt->rna_ext.srna;
2287 }
2288
2289 static StructRNA *rna_FunctionNode_register(Main *bmain,
2290                                             ReportList *reports,
2291                                             void *data,
2292                                             const char *identifier,
2293                                             StructValidateFunc validate,
2294                                             StructCallbackFunc call,
2295                                             StructFreeFunc free)
2296 {
2297   bNodeType *nt = rna_Node_register_base(
2298       bmain, reports, &RNA_FunctionNode, data, identifier, validate, call, free);
2299   if (!nt) {
2300     return NULL;
2301   }
2302
2303   nodeRegisterType(nt);
2304
2305   /* update while blender is running */
2306   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2307
2308   return nt->rna_ext.srna;
2309 }
2310
2311 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
2312 {
2313   bNode *node = ptr->data;
2314
2315   if (create && !node->prop) {
2316     IDPropertyTemplate val = {0};
2317     node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
2318   }
2319
2320   return node->prop;
2321 }
2322
2323 static void rna_Node_parent_set(PointerRNA *ptr,
2324                                 PointerRNA value,
2325                                 struct ReportList *UNUSED(reports))
2326 {
2327   bNode *node = ptr->data;
2328   bNode *parent = value.data;
2329
2330   if (parent) {
2331     /* XXX only Frame node allowed for now,
2332      * in the future should have a poll function or so to test possible attachment.
2333      */
2334     if (parent->type != NODE_FRAME) {
2335       return;
2336     }
2337
2338     /* make sure parent is not attached to the node */
2339     if (nodeAttachNodeCheck(parent, node)) {
2340       return;
2341     }
2342   }
2343
2344   nodeDetachNode(node);
2345   if (parent) {
2346     nodeAttachNode(node, parent);
2347   }
2348 }
2349
2350 static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
2351 {
2352   bNode *node = ptr->data;
2353   bNode *parent = value.data;
2354
2355   /* XXX only Frame node allowed for now,
2356    * in the future should have a poll function or so to test possible attachment.
2357    */
2358   if (parent->type != NODE_FRAME) {
2359     return false;
2360   }
2361
2362   /* make sure parent is not attached to the node */
2363   if (nodeAttachNodeCheck(parent, node)) {
2364     return false;
2365   }
2366
2367   return true;
2368 }
2369
2370 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2371 {
2372   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2373   bNode *node = (bNode *)ptr->data;
2374   ED_node_tag_update_nodetree(bmain, ntree, node);
2375 }
2376
2377 static void rna_Node_update_relations(Main *bmain, Scene *scene, PointerRNA *ptr)
2378 {
2379   rna_Node_update(bmain, scene, ptr);
2380   DEG_relations_tag_update(bmain);
2381 }
2382
2383 static void rna_Node_socket_value_update(ID *id, bNode *node, bContext *C)
2384 {
2385   ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id, node);
2386 }
2387
2388 static void rna_Node_select_set(PointerRNA *ptr, bool value)
2389 {
2390   bNode *node = (bNode *)ptr->data;
2391   nodeSetSelected(node, value);
2392 }
2393
2394 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
2395 {
2396   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2397   bNode *node = (bNode *)ptr->data;
2398   char oldname[sizeof(node->name)];
2399
2400   /* make a copy of the old name first */
2401   BLI_strncpy(oldname, node->name, sizeof(node->name));
2402   /* set new name */
2403   BLI_strncpy_utf8(node->name, value, sizeof(node->name));
2404
2405   nodeUniqueName(ntree, node);
2406
2407   /* fix all the animation data which may link to this */
2408   BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
2409 }
2410
2411 static bNodeSocket *rna_Node_inputs_new(ID *id,
2412                                         bNode *node,
2413                                         Main *bmain,
2414                                         ReportList *reports,
2415                                         const char *type,
2416                                         const char *name,
2417                                         const char *identifier)
2418 {
2419
2420   if (ELEM(node->type, NODE_GROUP_INPUT, NODE_FRAME)) {
2421     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2422     return NULL;
2423   }
2424   /* Adding an input to a group node is not working,
2425    * simpler to add it to its underlying nodetree. */
2426   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
2427     return rna_NodeTree_inputs_new((bNodeTree *)node->id, bmain, reports, type, name);
2428   }
2429
2430   bNodeTree *ntree = (bNodeTree *)id;
2431   bNodeSocket *sock;
2432
2433   sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
2434
2435   if (sock == NULL) {
2436     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2437   }
2438   else {
2439     ntreeUpdateTree(bmain, ntree);
2440     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2441   }
2442
2443   return sock;
2444 }
2445
2446 static bNodeSocket *rna_Node_outputs_new(ID *id,
2447                                          bNode *node,
2448                                          Main *bmain,
2449                                          ReportList *reports,
2450                                          const char *type,
2451                                          const char *name,
2452                                          const char *identifier)
2453 {
2454   if (ELEM(node->type, NODE_GROUP_OUTPUT, NODE_FRAME)) {
2455     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2456     return NULL;
2457   }
2458   /* Adding an output to a group node is not working,
2459    * simpler to add it to its underlying nodetree. */
2460   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
2461     return rna_NodeTree_outputs_new((bNodeTree *)node->id, bmain, reports, type, name);
2462   }
2463
2464   bNodeTree *ntree = (bNodeTree *)id;
2465   bNodeSocket *sock;
2466
2467   sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
2468
2469   if (sock == NULL) {
2470     BKE_report(reports, RPT_ERROR, "Unable to create socket");
2471   }
2472   else {
2473     ntreeUpdateTree(bmain, ntree);
2474     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2475   }
2476
2477   return sock;
2478 }
2479
2480 static void rna_Node_socket_remove(
2481     ID *id, bNode *node, Main *bmain, ReportList *reports, bNodeSocket *sock)
2482 {
2483   bNodeTree *ntree = (bNodeTree *)id;
2484
2485   if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
2486     BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
2487   }
2488   else {
2489     nodeRemoveSocket(ntree, node, sock);
2490
2491     ntreeUpdateTree(bmain, ntree);
2492     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2493   }
2494 }
2495
2496 static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain)
2497 {
2498   bNodeTree *ntree = (bNodeTree *)id;
2499   bNodeSocket *sock, *nextsock;
2500
2501   for (sock = node->inputs.first; sock; sock = nextsock) {
2502     nextsock = sock->next;
2503     nodeRemoveSocket(ntree, node, sock);
2504   }
2505
2506   ntreeUpdateTree(bmain, ntree);
2507   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2508 }
2509
2510 static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain)
2511 {
2512   bNodeTree *ntree = (bNodeTree *)id;
2513   bNodeSocket *sock, *nextsock;
2514
2515   for (sock = node->outputs.first; sock; sock = nextsock) {
2516     nextsock = sock->next;
2517     nodeRemoveSocket(ntree, node, sock);
2518   }
2519
2520   ntreeUpdateTree(bmain, ntree);
2521   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2522 }
2523
2524 static void rna_Node_inputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
2525 {
2526   bNodeTree *ntree = (bNodeTree *)id;
2527   bNodeSocket *sock;
2528
2529   if (from_index == to_index) {
2530     return;
2531   }
2532   if (from_index < 0 || to_index < 0) {
2533     return;
2534   }
2535
2536   sock = BLI_findlink(&node->inputs, from_index);
2537   if (to_index < from_index) {
2538     bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
2539     if (nextsock) {
2540       BLI_remlink(&node->inputs, sock);
2541       BLI_insertlinkbefore(&node->inputs, nextsock, sock);
2542     }
2543   }
2544   else {
2545     bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
2546     if (prevsock) {
2547       BLI_remlink(&node->inputs, sock);
2548       BLI_insertlinkafter(&node->inputs, prevsock, sock);
2549     }
2550   }
2551
2552   ntreeUpdateTree(bmain, ntree);
2553   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2554 }
2555
2556 static void rna_Node_outputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
2557 {
2558   bNodeTree *ntree = (bNodeTree *)id;
2559   bNodeSocket *sock;
2560
2561   if (from_index == to_index) {
2562     return;
2563   }
2564   if (from_index < 0 || to_index < 0) {
2565     return;
2566   }
2567
2568   sock = BLI_findlink(&node->outputs, from_index);
2569   if (to_index < from_index) {
2570     bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
2571     if (nextsock) {
2572       BLI_remlink(&node->outputs, sock);
2573       BLI_insertlinkbefore(&node->outputs, nextsock, sock);
2574     }
2575   }
2576   else {
2577     bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
2578     if (prevsock) {
2579       BLI_remlink(&node->outputs, sock);
2580       BLI_insertlinkafter(&node->outputs, prevsock, sock);
2581     }
2582   }
2583
2584   ntreeUpdateTree(bmain, ntree);
2585   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2586 }
2587
2588 static void rna_Node_width_range(
2589     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2590 {
2591   bNode *node = ptr->data;
2592   *min = *softmin = node->typeinfo->minwidth;
2593   *max = *softmax = node->typeinfo->maxwidth;
2594 }
2595
2596 static void rna_Node_height_range(
2597     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2598 {
2599   bNode *node = ptr->data;
2600   *min = *softmin = node->typeinfo->minheight;
2601   *max = *softmax = node->typeinfo->maxheight;
2602 }
2603
2604 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
2605 {
2606   bNode *node = ptr->data;
2607   value[0] = node->totr.xmax - node->totr.xmin;
2608   value[1] = node->totr.ymax - node->totr.ymin;
2609 }
2610
2611 /* ******** Node Socket ******** */
2612
2613 static void rna_NodeSocket_draw(
2614     bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
2615 {
2616   extern FunctionRNA rna_NodeSocket_draw_func;
2617
2618   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2619   ParameterList list;
2620   FunctionRNA *func;
2621
2622   func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2623
2624   RNA_parameter_list_create(&list, ptr, func);
2625   RNA_parameter_set_lookup(&list, "context", &C);
2626   RNA_parameter_set_lookup(&list, "layout", &layout);
2627   RNA_parameter_set_lookup(&list, "node", node_ptr);
2628   RNA_parameter_set_lookup(&list, "text", &text);
2629   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
2630
2631   RNA_parameter_list_free(&list);
2632 }
2633
2634 static void rna_NodeSocket_draw_color(bContext *C,
2635                                       PointerRNA *ptr,
2636                                       PointerRNA *node_ptr,
2637                                       float *r_color)
2638 {
2639   extern FunctionRNA rna_NodeSocket_draw_color_func;
2640
2641   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2642   ParameterList list;
2643   FunctionRNA *func;
2644   void *ret;
2645
2646   func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2647
2648   RNA_parameter_list_create(&list, ptr, func);
2649   RNA_parameter_set_lookup(&list, "context", &C);
2650   RNA_parameter_set_lookup(&list, "node", node_ptr);
2651   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
2652
2653   RNA_parameter_get_lookup(&list, "color", &ret);
2654   copy_v4_v4(r_color, (float *)ret);
2655
2656   RNA_parameter_list_free(&list);
2657 }
2658
2659 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
2660 {
2661   bNodeSocketType *st = RNA_struct_blender_type_get(type);
2662   if (!st) {
2663     return;
2664   }
2665
2666   RNA_struct_free_extension(type, &st->ext_socket);
2667   RNA_struct_free(&BLENDER_RNA, type);
2668
2669   nodeUnregisterSocketType(st);
2670
2671   /* update while blender is running */
2672   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2673 }
2674
2675 static StructRNA *rna_NodeSocket_register(Main *UNUSED(bmain),
2676                                           ReportList *reports,
2677                                           void *data,
2678                                           const char *identifier,
2679                                           StructValidateFunc validate,
2680                                           StructCallbackFunc call,
2681                                           StructFreeFunc free)
2682 {
2683   bNodeSocketType *st, dummyst;
2684   bNodeSocket dummysock;
2685   PointerRNA dummyptr;
2686   int have_function[2];
2687
2688   /* setup dummy socket & socket type to store static properties in */
2689   memset(&dummyst, 0, sizeof(bNodeSocketType));
2690
2691   memset(&dummysock, 0, sizeof(bNodeSocket));
2692   dummysock.typeinfo = &dummyst;
2693   RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
2694
2695   /* validate the python class */
2696   if (validate(&dummyptr, data, have_function) != 0) {
2697     return NULL;
2698   }
2699
2700   if (strlen(identifier) >= sizeof(dummyst.idname)) {
2701     BKE_reportf(reports,
2702                 RPT_ERROR,
2703                 "Registering node socket class: '%s' is too long, maximum length is %d",
2704                 identifier,
2705                 (int)sizeof(dummyst.idname));
2706     return NULL;
2707   }
2708
2709   /* check if we have registered this socket type before */
2710   st = nodeSocketTypeFind(dummyst.idname);
2711   if (!st) {
2712     /* create a new node socket type */
2713     st = MEM_mallocN(sizeof(bNodeSocketType), "node socket type");
2714     memcpy(st, &dummyst, sizeof(dummyst));
2715
2716     nodeRegisterSocketType(st);
2717   }
2718
2719   st->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
2720
2721   /* if RNA type is already registered, unregister first */
2722   if (st->ext_socket.srna) {
2723     StructRNA *srna = st->ext_socket.srna;
2724     RNA_struct_free_extension(srna, &st->ext_socket);
2725     RNA_struct_free(&BLENDER_RNA, srna);
2726   }
2727   st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket);
2728   st->ext_socket.data = data;
2729   st->ext_socket.call = call;
2730   st->ext_socket.free = free;
2731   RNA_struct_blender_type_set(st->ext_socket.srna, st);
2732
2733   /* XXX bad level call! needed to initialize the basic draw functions ... */
2734   ED_init_custom_node_socket_type(st);
2735
2736   st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
2737   st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
2738
2739   /* update while blender is running */
2740   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2741
2742   return st->ext_socket.srna;
2743 }
2744
2745 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
2746 {
2747   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2748
2749   if (sock->typeinfo->ext_socket.srna) {
2750     return sock->typeinfo->ext_socket.srna;
2751   }
2752   else {
2753     return &RNA_NodeSocket;
2754   }
2755 }
2756
2757 static char *rna_NodeSocket_path(PointerRNA *ptr)
2758 {
2759   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2760   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2761   bNode *node;
2762   int socketindex;
2763   char name_esc[sizeof(node->name) * 2];
2764
2765   if (!nodeFindNode(ntree, sock, &node, &socketindex)) {
2766     return NULL;
2767   }
2768
2769   BLI_str_escape(name_esc, node->name, sizeof(name_esc));
2770
2771   if (sock->in_out == SOCK_IN) {
2772     return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
2773   }
2774   else {
2775     return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
2776   }
2777 }
2778
2779 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
2780 {
2781   bNodeSocket *sock = ptr->data;
2782
2783   if (create && !sock->prop) {
2784     IDPropertyTemplate val = {0};
2785     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
2786   }
2787
2788   return sock->prop;
2789 }
2790
2791 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
2792 {
2793   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2794   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2795   bNode *node;
2796   PointerRNA r_ptr;
2797
2798   nodeFindNode(ntree, sock, &node, NULL);
2799
2800   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
2801   return r_ptr;
2802 }
2803
2804 static void rna_NodeSocket_type_set(PointerRNA *ptr, int value)
2805 {
2806   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2807   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2808   bNode *node;
2809   nodeFindNode(ntree, sock, &node, NULL);
2810   nodeModifySocketType(ntree, node, sock, value, 0);
2811 }
2812
2813 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2814 {
2815   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
2816   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2817   bNode *node;
2818   if (nodeFindNode(ntree, sock, &node, NULL)) {
2819     ED_node_tag_update_nodetree(bmain, ntree, node);
2820   }
2821 }
2822
2823 static bool rna_NodeSocket_is_output_get(PointerRNA *ptr)
2824 {
2825   bNodeSocket *sock = ptr->data;
2826   return sock->in_out == SOCK_OUT;
2827 }
2828
2829 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
2830 {
2831   /* Does not have any effect if the link limit is defined in the socket type. */
2832   bNodeSocket *sock = ptr->data;
2833   sock->limit = (value == 0 ? 0xFFF : value);
2834 }
2835
2836 static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
2837 {
2838   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2839
2840   /* don't hide linked sockets */
2841   if (sock->flag & SOCK_IN_USE) {
2842     return;
2843   }
2844
2845   if (value) {
2846     sock->flag |= SOCK_HIDDEN;
2847   }
2848   else {
2849     sock->flag &= ~SOCK_HIDDEN;
2850   }
2851 }
2852
2853 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
2854 {
2855   extern FunctionRNA rna_NodeSocketInterface_draw_func;
2856
2857   bNodeSocket *stemp = (bNodeSocket *)ptr->data;
2858   ParameterList list;
2859   FunctionRNA *func;
2860
2861   if (!stemp->typeinfo) {
2862     return;
2863   }
2864
2865   func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2866
2867   RNA_parameter_list_create(&list, ptr, func);
2868   RNA_parameter_set_lookup(&list, "context", &C);
2869   RNA_parameter_set_lookup(&list, "layout", &layout);
2870   stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
2871
2872   RNA_parameter_list_free(&list);
2873 }
2874
2875 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
2876 {
2877   extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
2878
2879   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2880   ParameterList list;
2881   FunctionRNA *func;
2882   void *ret;
2883
2884   if (!sock->typeinfo) {
2885     return;
2886   }
2887
2888   func =
2889       &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2890
2891   RNA_parameter_list_create(&list, ptr, func);
2892   RNA_parameter_set_lookup(&list, "context", &C);
2893   sock->typeinfo->ext_interface.call(C, ptr, func, &list);
2894
2895   RNA_parameter_get_lookup(&list, "color", &ret);
2896   copy_v4_v4(r_color, (float *)ret);
2897
2898   RNA_parameter_list_free(&list);
2899 }
2900
2901 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree,
2902                                                         bNodeSocket *stemp,
2903                                                         StructRNA *data_srna)
2904 {
2905   extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
2906
2907   PointerRNA ptr;
2908   ParameterList list;
2909   FunctionRNA *func;
2910
2911   if (!stemp->typeinfo) {
2912     return;
2913   }
2914
2915   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2916   /* RNA_struct_find_function(&ptr, "register_properties"); */
2917   func = &rna_NodeSocketInterface_register_properties_func;
2918
2919   RNA_parameter_list_create(&list, &ptr, func);
2920   RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
2921   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2922
2923   RNA_parameter_list_free(&list);
2924 }
2925
2926 static void rna_NodeSocketInterface_init_socket(
2927     bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
2928 {
2929   extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
2930
2931   PointerRNA ptr, node_ptr, sock_ptr;
2932   ParameterList list;
2933   FunctionRNA *func;
2934
2935   if (!stemp->typeinfo) {
2936     return;
2937   }
2938
2939   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2940   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2941   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2942   /* RNA_struct_find_function(&ptr, "init_socket"); */
2943   func = &rna_NodeSocketInterface_init_socket_func;
2944
2945   RNA_parameter_list_create(&list, &ptr, func);
2946   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2947   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2948   RNA_parameter_set_lookup(&list, "data_path", &data_path);
2949   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2950
2951   RNA_parameter_list_free(&list);
2952 }
2953
2954 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree,
2955                                                 bNodeSocket *stemp,
2956                                                 bNode *node,
2957                                                 bNodeSocket *sock)
2958 {
2959   extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2960
2961   PointerRNA ptr, node_ptr, sock_ptr;
2962   ParameterList list;
2963   FunctionRNA *func;
2964
2965   if (!stemp->typeinfo) {
2966     return;
2967   }
2968
2969   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2970   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2971   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2972   /* RNA_struct_find_function(&ptr, "from_socket"); */
2973   func = &rna_NodeSocketInterface_from_socket_func;
2974
2975   RNA_parameter_list_create(&list, &ptr, func);
2976   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2977   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2978   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2979
2980   RNA_parameter_list_free(&list);
2981 }
2982
2983 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2984 {
2985   bNodeSocketType *st = RNA_struct_blender_type_get(type);
2986   if (!st) {
2987     return;
2988   }
2989
2990   RNA_struct_free_extension(type, &st->ext_interface);
2991
2992   RNA_struct_free(&BLENDER_RNA, type);
2993
2994   /* update while blender is running */
2995   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2996 }
2997
2998 static StructRNA *rna_NodeSocketInterface_register(Main *UNUSED(bmain),
2999                                                    ReportList *UNUSED(reports),
3000                                                    void *data,
3001                                                    const char *identifier,
3002                                                    StructValidateFunc validate,
3003                                                    StructCallbackFunc call,
3004                                                    StructFreeFunc free)
3005 {
3006   bNodeSocketType *st, dummyst;
3007   bNodeSocket dummysock;
3008   PointerRNA dummyptr;
3009   int have_function[5];
3010
3011   /* setup dummy socket & socket type to store static properties in */
3012   memset(&dummyst, 0, sizeof(bNodeSocketType));
3013
3014   memset(&dummysock, 0, sizeof(bNodeSocket));
3015   dummysock.typeinfo = &dummyst;
3016   RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
3017
3018   /* validate the python class */
3019   if (validate(&dummyptr, data, have_function) != 0) {
3020     return NULL;
3021   }
3022
3023   /* check if we have registered this socket type before */
3024   st = nodeSocketTypeFind(dummyst.idname);
3025   if (st) {
3026     /* basic socket type registered by a socket class before. */
3027   }
3028   else {
3029     /* create a new node socket type */
3030     st = MEM_mallocN(sizeof(bNodeSocketType), "node socket type");
3031     memcpy(st, &dummyst, sizeof(dummyst));
3032
3033     nodeRegisterSocketType(st);
3034   }
3035
3036   st->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
3037
3038   /* if RNA type is already registered, unregister first */
3039   if (st->ext_interface.srna) {
3040     StructRNA *srna = st->ext_interface.srna;
3041     RNA_struct_free_extension(srna, &st->ext_interface);
3042     RNA_struct_free(&BLENDER_RNA, srna);
3043   }
3044   st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface);
3045   st->ext_interface.data = data;
3046   st->ext_interface.call = call;
3047   st->ext_interface.free = free;
3048   RNA_struct_blender_type_set(st->ext_interface.srna, st);
3049
3050   st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
3051   st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
3052   st->interface_register_properties = (have_function[2]) ?
3053                                           rna_NodeSocketInterface_register_properties :
3054                                           NULL;
3055   st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
3056   st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
3057
3058   /* update while blender is running */
3059   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3060
3061   return st->ext_interface.srna;
3062 }
3063
3064 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
3065 {
3066   bNodeSocket *sock = (bNodeSocket *)ptr->data;
3067
3068   if (sock->typeinfo && sock->typeinfo->ext_interface.srna) {
3069     return sock->typeinfo->ext_interface.srna;
3070   }
3071   else {
3072     return &RNA_NodeSocketInterface;
3073   }
3074 }
3075
3076 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
3077 {
3078   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3079   bNodeSocket *sock = (bNodeSocket *)ptr->data;
3080   int socketindex;
3081
3082   socketindex = BLI_findindex(&ntree->inputs, sock);
3083   if (socketindex != -1) {
3084     return BLI_sprintfN("inputs[%d]", socketindex);
3085   }
3086
3087   socketindex = BLI_findindex(&ntree->outputs, sock);
3088   if (socketindex != -1) {
3089     return BLI_sprintfN("outputs[%d]", socketindex);
3090   }
3091
3092   return NULL;
3093 }
3094
3095 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
3096 {
3097   bNodeSocket *sock = ptr->data;
3098
3099   if (create && !sock->prop) {
3100     IDPropertyTemplate val = {0};
3101     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
3102   }
3103
3104   return sock->prop;
3105 }
3106
3107 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3108 {
3109   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3110   bNodeSocket *stemp = ptr->data;
3111
3112   if (!stemp->typeinfo) {
3113     return;
3114   }
3115
3116   ntree->update |= NTREE_UPDATE_GROUP;
3117   ntreeUpdateTree(bmain, ntree);
3118
3119   ED_node_tag_update_nodetree(bmain, ntree, NULL);
3120 }
3121
3122 /* ******** Standard Node Socket Base Types ******** */
3123
3124 static void rna_NodeSocketStandard_draw(ID *id,
3125                                         bNodeSocket *sock,
3126                                         struct bContext *C,
3127                                         struct uiLayout *layout,
3128                                         PointerRNA *nodeptr,
3129                                         const char *text)
3130 {
3131   PointerRNA ptr;
3132   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3133   sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
3134 }
3135
3136 static void rna_NodeSocketStandard_draw_color(
3137     ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float r_color[4])
3138 {
3139   PointerRNA ptr;
3140   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3141   sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
3142 }
3143
3144 static void rna_NodeSocketInterfaceStandard_draw(ID *id,
3145                                                  bNodeSocket *sock,
3146                                                  struct bContext *C,
3147                                                  struct uiLayout *layout)
3148 {
3149   PointerRNA ptr;
3150   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3151   sock->typeinfo->interface_draw(C, layout, &ptr);
3152 }
3153
3154 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id,
3155                                                        bNodeSocket *sock,
3156                                                        struct bContext *C,
3157                                                        float r_color[4])
3158 {
3159   PointerRNA ptr;
3160   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
3161   sock->typeinfo->interface_draw_color(C, &ptr, r_color);
3162 }
3163
3164 static void rna_NodeSocketStandard_float_range(
3165     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3166 {
3167   bNodeSocket *sock = ptr->data;
3168   bNodeSocketValueFloat *dval = sock->default_value;
3169   int subtype = sock->typeinfo->subtype;
3170
3171   if (dval->max < dval->min) {
3172     dval->max = dval->min;
3173   }
3174
3175   *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
3176   *max = FLT_MAX;
3177   *softmin = dval->min;
3178   *softmax = dval->max;
3179 }
3180
3181 static void rna_NodeSocketStandard_int_range(
3182     PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
3183 {
3184   bNodeSocket *sock = ptr->data;
3185   bNodeSocketValueInt *dval = sock->default_value;
3186   int subtype = sock->typeinfo->subtype;
3187
3188   if (dval->max < dval->min) {
3189     dval->max = dval->min;
3190   }
3191
3192   *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
3193   *max = INT_MAX;
3194   *softmin = dval->min;
3195   *softmax = dval->max;
3196 }
3197
3198 static void rna_NodeSocketStandard_vector_range(
3199     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
3200 {
3201   bNodeSocket *sock = ptr->data;
3202   bNodeSocketValueVector *dval = sock->default_value;
3203
3204   if (dval->max < dval->min) {
3205     dval->max = dval->min;
3206   }
3207
3208   *min = -FLT_MAX;
3209   *max = FLT_MAX;
3210   *softmin = dval->min;
3211   *softmax = dval->max;
3212 }
3213
3214 /* using a context update function here, to avoid searching the node if possible */
3215 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
3216 {
3217   bNode *node;
3218
3219   /* default update */
3220   rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
3221
3222   /* try to use node from context, faster */
3223   node = CTX_data_pointer_get(C, "node").data;
3224   if (!node) {
3225     bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3226     bNodeSocket *sock = ptr->data;
3227
3228     /* fall back to searching node in the tree */
3229     nodeFindNode(ntree, sock, &node, NULL);
3230   }
3231 }
3232
3233 static void rna_NodeSocketStandard_value_and_relation_update(struct bContext *C, PointerRNA *ptr)
3234 {
3235   rna_NodeSocketStandard_value_update(C, ptr);
3236   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3237   Main *bmain = CTX_data_main(C);
3238   ntreeUpdateTree(bmain, ntree);
3239   DEG_relations_tag_update(bmain);
3240 }
3241
3242 /* ******** Node Types ******** */
3243
3244 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
3245 {
3246   bNodeSocketTemplate *stemp = ptr->data;
3247   strcpy(value, stemp->name);
3248 }
3249
3250 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
3251 {
3252   bNodeSocketTemplate *stemp = ptr->data;
3253   return strlen(stemp->name);
3254 }
3255
3256 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
3257 {
3258   bNodeSocketTemplate *stemp = ptr->data;
3259   strcpy(value, stemp->identifier);
3260 }
3261
3262 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
3263 {
3264   bNodeSocketTemplate *stemp = ptr->data;
3265   return strlen(stemp->identifier);
3266 }
3267
3268 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
3269 {
3270   bNodeSocketTemplate *stemp = ptr->data;
3271   return stemp->type;
3272 }
3273
3274 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
3275 {
3276   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3277   if (ntype && ntype->inputs) {
3278     bNodeSocketTemplate *stemp = ntype->inputs;
3279     int i = 0;
3280     while (i < index && stemp->type >= 0) {
3281       i++;
3282       stemp++;
3283     }
3284     if (i == index && stemp->type >= 0) {
3285       PointerRNA ptr;
3286       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
3287       return ptr;
3288     }
3289   }
3290   return PointerRNA_NULL;
3291 }
3292
3293 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
3294 {
3295   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3296   if (ntype && ntype->outputs) {
3297     bNodeSocketTemplate *stemp = ntype->outputs;
3298     int i = 0;
3299     while (i < index && stemp->type >= 0) {
3300       i++;
3301       stemp++;
3302     }
3303     if (i == index && stemp->type >= 0) {
3304       PointerRNA ptr;
3305       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
3306       return ptr;
3307     }
3308   }
3309   return PointerRNA_NULL;
3310 }
3311
3312 static bool rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
3313 {
3314   bNodeType *ntype = RNA_struct_blender_type_get(srna);
3315   const char *disabled_hint;
3316   return ntype && (!ntype->poll || ntype->poll(ntype, ntree, &disabled_hint));
3317 }
3318
3319 static bool rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
3320 {
3321   bNodeType *ntype = node->typeinfo;
3322   const char *disabled_hint;
3323   if (ntype->poll_instance) {
3324     return ntype->poll_instance(node, ntree, &disabled_hint);
3325   }
3326   else {
3327     /* fall back to basic poll function */
3328     return !ntype->poll || ntype->poll(ntype, ntree, &disabled_hint);
3329   }
3330 }
3331
3332 static void rna_NodeInternal_update(ID *id, bNode *node)
3333 {
3334   bNodeTree *ntree = (bNodeTree *)id;
3335   if (node->typeinfo->updatefunc) {
3336     node->typeinfo->updatefunc(ntree, node);
3337   }
3338 }
3339
3340 static void rna_NodeInternal_draw_buttons(ID *id,
3341                                           bNode *node,
3342                                           struct bContext *C,
3343                                           struct uiLayout *layout)
3344 {
3345   if (node->typeinfo->draw_buttons) {
3346     PointerRNA ptr;
3347     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3348     node->typeinfo->draw_buttons(layout, C, &ptr);
3349   }
3350 }
3351
3352 static void rna_NodeInternal_draw_buttons_ext(ID *id,
3353                                               bNode *node,
3354                                               struct bContext *C,
3355                                               struct uiLayout *layout)
3356 {
3357   if (node->typeinfo->draw_buttons_ex) {
3358     PointerRNA ptr;
3359     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3360     node->typeinfo->draw_buttons_ex(layout, C, &ptr);
3361   }
3362   else if (node->typeinfo->draw_buttons) {
3363     PointerRNA ptr;
3364     RNA_pointer_create(id, &RNA_Node, node, &ptr);
3365     node->typeinfo->draw_buttons(layout, C, &ptr);
3366   }
3367 }
3368
3369 static StructRNA *rna_NodeCustomGroup_register(Main *bmain,
3370                                                ReportList *reports,
3371                                                void *data,
3372                                                const char *identifier,
3373                                                StructValidateFunc validate,
3374                                                StructCallbackFunc call,
3375                                                StructFreeFunc free)
3376 {
3377   bNodeType *nt = rna_Node_register_base(
3378       bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
3379   if (!nt) {
3380     return NULL;
3381   }
3382
3383   /* this updates the group node instance from the tree's interface */
3384   nt->group_update_func = node_group_update;
3385
3386   nodeRegisterType(nt);
3387
3388   /* update while blender is running */
3389   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3390
3391   return nt->rna_ext.srna;
3392 }
3393
3394 static StructRNA *rna_GeometryNodeCustomGroup_register(Main *bmain,
3395                                                        ReportList *reports,
3396                                                        void *data,
3397                                                        const char *identifier,
3398                                                        StructValidateFunc validate,
3399                                                        StructCallbackFunc call,
3400                                                        StructFreeFunc free)
3401 {
3402   bNodeType *nt = rna_Node_register_base(
3403       bmain, reports, &RNA_GeometryNodeCustomGroup, data, identifier, validate, call, free);
3404
3405   if (!nt) {
3406     return NULL;
3407   }
3408
3409   nt->group_update_func = node_group_update;
3410   nt->type = NODE_CUSTOM_GROUP;
3411
3412   register_node_type_geo_custom_group(nt);
3413
3414   nodeRegisterType(nt);
3415
3416   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3417
3418   return nt->rna_ext.srna;
3419 }
3420
3421 void register_node_type_geo_custom_group(bNodeType *ntype);
3422
3423 static StructRNA *rna_ShaderNodeCustomGroup_register(Main *bmain,
3424                                                      ReportList *reports,
3425                                                      void *data,
3426                                                      const char *identifier,
3427                                                      StructValidateFunc validate,
3428                                                      StructCallbackFunc call,
3429                                                      StructFreeFunc free)
3430 {
3431   bNodeType *nt = rna_Node_register_base(
3432       bmain, reports, &RNA_ShaderNodeCustomGroup, data, identifier, validate, call, free);
3433
3434   if (!nt) {
3435     return NULL;
3436   }
3437
3438   nt->group_update_func = node_group_update;
3439   nt->type = NODE_CUSTOM_GROUP;
3440
3441   register_node_type_sh_custom_group(nt);
3442
3443   nodeRegisterType(nt);
3444
3445   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3446
3447   return nt->rna_ext.srna;
3448 }
3449
3450 static StructRNA *rna_CompositorNodeCustomGroup_register(Main *bmain,
3451                                                          ReportList *reports,
3452                                                          void *data,
3453                                                          const char *identifier,
3454                                                          StructValidateFunc validate,
3455                                                          StructCallbackFunc call,
3456                                                          StructFreeFunc free)
3457 {
3458   bNodeType *nt = rna_Node_register_base(
3459       bmain, reports, &RNA_CompositorNodeCustomGroup, data, identifier, validate, call, free);
3460   if (!nt) {
3461     return NULL;
3462   }
3463
3464   nt->group_update_func = node_group_update;
3465   nt->type = NODE_CUSTOM_GROUP;
3466
3467   register_node_type_cmp_custom_group(nt);
3468
3469   nodeRegisterType(nt);
3470
3471   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
3472
3473   return nt->rna_ext.srna;
3474 }
3475
3476 static void rna_CompositorNode_tag_need_exec(bNode *node)
3477 {
3478   node->need_exec = true;
3479 }
3480
3481 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3482 {
3483   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3484   bNode *node = (bNode *)ptr->data;
3485
3486   ED_node_tag_update_nodetree(bmain, ntree, node);
3487   WM_main_add_notifier(NC_IMAGE, NULL);
3488 }
3489
3490 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3491 {
3492   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3493   bNode *node = (bNode *)ptr->data;
3494
3495   if (node->id) {
3496     ntreeUpdateTree(bmain, (bNodeTree *)node->id);
3497   }
3498
3499   ED_node_tag_update_nodetree(bmain, ntree, node);
3500   DEG_relations_tag_update(bmain);
3501 }
3502
3503 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr,
3504                                         const PointerRNA value,
3505                                         struct ReportList *UNUSED(reports))
3506 {
3507   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3508   bNode *node = ptr->data;
3509   bNodeTree *ngroup = value.data;
3510
3511   const char *disabled_hint = NULL;
3512   if (nodeGroupPoll(ntree, ngroup, &disabled_hint)) {
3513     if (node->id) {
3514       id_us_min(node->id);
3515     }
3516     if (ngroup) {
3517       id_us_plus(&ngroup->id);
3518     }
3519
3520     node->id = &ngroup->id;
3521   }
3522 }
3523
3524 static bool rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
3525 {
3526   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3527   bNodeTree *ngroup = value.data;
3528
3529   /* only allow node trees of the same type as the group node's tree */
3530   if (ngroup->type != ntree->type) {
3531     return false;
3532   }
3533
3534   const char *disabled_hint = NULL;
3535   return nodeGroupPoll(ntree, ngroup, &disabled_hint);
3536 }
3537
3538 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
3539 {
3540   bNode *node = ptr->data;
3541   bNodeTree *ngroup = (bNodeTree *)node->id;
3542
3543   if (ngroup) {
3544     StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
3545     if (srna) {
3546       return srna;
3547     }
3548   }
3549   return &RNA_PropertyGroup;
3550 }
3551
3552 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
3553 {
3554   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3555
3556   if (ntree) {
3557     StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
3558     if (srna) {
3559       return srna;
3560     }
3561   }
3562   return &RNA_PropertyGroup;
3563 }
3564
3565 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
3566 {
3567   bNode *node = (bNode *)ptr->data;
3568   NodeChroma *chroma = node->storage;
3569
3570   chroma->t1 = value;
3571 }
3572
3573 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
3574 {
3575   bNode *node = (bNode *)ptr->data;
3576   NodeChroma *chroma = node->storage;
3577
3578   chroma->t2 = value;
3579 }
3580
3581 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
3582 {
3583   bNode *node = (bNode *)ptr->data;
3584   NodeChroma *chroma = node->storage;
3585
3586   chroma->t1 = value;
3587 }
3588
3589 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
3590 {
3591   bNode *node = (bNode *)ptr->data;
3592   NodeChroma *chroma = node->storage;
3593
3594   chroma->t2 = value;
3595 }
3596
3597 /* Button Set Funcs for Matte Nodes */
3598 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
3599 {
3600   bNode *node = (bNode *)ptr->data;
3601   NodeChroma *chroma = node->storage;
3602
3603   chroma->t1 = value;
3604
3605   if (value < chroma->t2) {
3606     chroma->t2 = value;
3607   }
3608 }
3609
3610 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
3611 {
3612   bNode *node = (bNode *)ptr->data;
3613   NodeChroma *chroma = node->storage;
3614
3615   if (value > chroma->t1) {
3616     value = chroma->t1;
3617   }
3618
3619   chroma->t2 = value;
3620 }
3621
3622 static void rna_Node_scene_set(PointerRNA *ptr,
3623                                PointerRNA value,
3624                                struct ReportList *UNUSED(reports))
3625 {
3626   bNode *node = (bNode *)ptr->data;
3627
3628   if (node->id) {
3629     id_us_min(node->id);
3630     node->id = NULL;
3631   }
3632
3633   node->id = value.data;
3634
3635   id_us_plus(node->id);
3636 }
3637
3638 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3639 {
3640   bNode *node = (bNode *)ptr->data;
3641   Image *ima = (Image *)node->id;
3642   ImageUser *iuser = node->storage;
3643
3644   if (node->type == CMP_NODE_CRYPTOMATTE && node->custom1 != CMP_CRYPTOMATTE_SRC_IMAGE) {
3645     return;
3646   }
3647
3648   BKE_image_multilayer_index(ima->rr, iuser);
3649   BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_SRC_CHANGE);
3650
3651   rna_Node_update(bmain, scene, ptr);
3652
3653   if (scene->nodetree != NULL) {
3654     ntreeCompositUpdateRLayers(scene->nodetree);
3655   }
3656 }
3657
3658 static const EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
3659 {
3660   EnumPropertyItem *item = NULL;
3661   EnumPropertyItem tmp = {0};
3662   int i = 0, totitem = 0;
3663
3664   while (rl) {
3665     tmp.identifier = rl->name;
3666     /* Little trick: using space char instead empty string
3667      * makes the item selectable in the drop-down. */
3668     if (rl->name[0] == '\0') {