Workbench: API Changes
[blender.git] / source / blender / makesrna / intern / rna_material.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008), Nathan Letwory
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_material.c
24  *  \ingroup RNA
25  */
26
27 #include <float.h>
28 #include <stdlib.h>
29
30 #include "DNA_material_types.h"
31 #include "DNA_texture_types.h"
32
33 #include "RNA_define.h"
34 #include "RNA_enum_types.h"
35
36 #include "rna_internal.h"
37
38 #include "WM_api.h"
39 #include "WM_types.h"
40
41 const EnumPropertyItem rna_enum_ramp_blend_items[] = {
42         {MA_RAMP_BLEND, "MIX", 0, "Mix", ""},
43         {MA_RAMP_ADD, "ADD", 0, "Add", ""},
44         {MA_RAMP_MULT, "MULTIPLY", 0, "Multiply", ""},
45         {MA_RAMP_SUB, "SUBTRACT", 0, "Subtract", ""},
46         {MA_RAMP_SCREEN, "SCREEN", 0, "Screen", ""},
47         {MA_RAMP_DIV, "DIVIDE", 0, "Divide", ""},
48         {MA_RAMP_DIFF, "DIFFERENCE", 0, "Difference", ""},
49         {MA_RAMP_DARK, "DARKEN", 0, "Darken", ""},
50         {MA_RAMP_LIGHT, "LIGHTEN", 0, "Lighten", ""},
51         {MA_RAMP_OVERLAY, "OVERLAY", 0, "Overlay", ""},
52         {MA_RAMP_DODGE, "DODGE", 0, "Dodge", ""},
53         {MA_RAMP_BURN, "BURN", 0, "Burn", ""},
54         {MA_RAMP_HUE, "HUE", 0, "Hue", ""},
55         {MA_RAMP_SAT, "SATURATION", 0, "Saturation", ""},
56         {MA_RAMP_VAL, "VALUE", 0, "Value", ""},
57         {MA_RAMP_COLOR, "COLOR", 0, "Color", ""},
58         {MA_RAMP_SOFT, "SOFT_LIGHT", 0, "Soft Light", ""},
59         {MA_RAMP_LINEAR, "LINEAR_LIGHT", 0, "Linear Light", ""},
60         {0, NULL, 0, NULL, NULL}
61 };
62
63 #ifdef RNA_RUNTIME
64
65 #include "MEM_guardedalloc.h"
66
67 #include "DNA_node_types.h"
68 #include "DNA_object_types.h"
69 #include "DNA_screen_types.h"
70 #include "DNA_space_types.h"
71
72 #include "BKE_colorband.h"
73 #include "BKE_context.h"
74 #include "BKE_main.h"
75 #include "BKE_material.h"
76 #include "BKE_texture.h"
77 #include "BKE_node.h"
78 #include "BKE_paint.h"
79 #include "BKE_scene.h"
80 #include "BKE_workspace.h"
81
82 #include "DEG_depsgraph.h"
83 #include "DEG_depsgraph_build.h"
84
85 #include "ED_node.h"
86 #include "ED_image.h"
87 #include "ED_screen.h"
88
89 static void rna_Material_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
90 {
91         Material *ma = ptr->id.data;
92
93         DEG_id_tag_update(&ma->id, DEG_TAG_COPY_ON_WRITE);
94         WM_main_add_notifier(NC_MATERIAL | ND_SHADING, ma);
95 }
96
97 static void rna_Material_update_previews(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
98 {
99         Material *ma = ptr->id.data;
100
101         if (ma->nodetree)
102                 BKE_node_preview_clear_tree(ma->nodetree);
103
104         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_PREVIEW, ma);
105 }
106
107 static void rna_Material_draw_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
108 {
109         Material *ma = ptr->id.data;
110
111         DEG_id_tag_update(&ma->id, DEG_TAG_COPY_ON_WRITE);
112         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, ma);
113 }
114
115 static void rna_Material_texpaint_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
116 {
117         Material *ma = (Material *)ptr->data;
118         rna_iterator_array_begin(iter, (void *)ma->texpaintslot, sizeof(TexPaintSlot), ma->tot_slots, 0, NULL);
119 }
120
121
122 static void rna_Material_active_paint_texture_index_update(Main *bmain, Scene *scene, PointerRNA *ptr)
123 {
124         bScreen *sc;
125         Material *ma = ptr->id.data;
126
127         if (ma->use_nodes && ma->nodetree) {
128                 struct bNode *node;
129                 int index = 0;
130                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
131                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
132                                 if (index++ == ma->paint_active_slot) {
133                                         break;
134                                 }
135                         }
136                 }
137                 if (node)
138                         nodeSetActive(ma->nodetree, node);
139         }
140
141         if (ma->texpaintslot) {
142                 Image *image = ma->texpaintslot[ma->paint_active_slot].ima;
143                 for (sc = bmain->screen.first; sc; sc = sc->id.next) {
144                         wmWindow *win = ED_screen_window_find(sc, bmain->wm.first);
145                         if (win == NULL) {
146                                 continue;
147                         }
148
149                         Object *obedit = NULL;
150                         {
151                                 WorkSpace *workspace = WM_window_get_active_workspace(win);
152                                 ViewLayer *view_layer = BKE_workspace_view_layer_get(workspace, scene);
153                                 obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
154                         }
155
156                         ScrArea *sa;
157                         for (sa = sc->areabase.first; sa; sa = sa->next) {
158                                 SpaceLink *sl;
159                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
160                                         if (sl->spacetype == SPACE_IMAGE) {
161                                                 SpaceImage *sima = (SpaceImage *)sl;
162                                                 if (!sima->pin) {
163                                                         ED_space_image_set(sima, scene, obedit, image);
164                                                 }
165                                         }
166                                 }
167                         }
168                 }
169         }
170
171         DEG_id_tag_update(&ma->id, 0);
172         WM_main_add_notifier(NC_MATERIAL | ND_SHADING, ma);
173 }
174
175 static void rna_Material_use_nodes_update(bContext *C, PointerRNA *ptr)
176 {
177         Material *ma = (Material *)ptr->data;
178         Main *bmain = CTX_data_main(C);
179
180         if (ma->use_nodes && ma->nodetree == NULL)
181                 ED_node_shader_default(C, &ma->id);
182
183         DEG_relations_tag_update(bmain);
184         rna_Material_draw_update(bmain, CTX_data_scene(C), ptr);
185 }
186
187 MTex *rna_mtex_texture_slots_add(ID *self_id, struct bContext *C, ReportList *reports)
188 {
189         MTex *mtex = BKE_texture_mtex_add_id(self_id, -1);
190         if (mtex == NULL) {
191                 BKE_reportf(reports, RPT_ERROR, "Maximum number of textures added %d", MAX_MTEX);
192                 return NULL;
193         }
194
195         /* for redraw only */
196         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
197
198         return mtex;
199 }
200
201 MTex *rna_mtex_texture_slots_create(ID *self_id, struct bContext *C, ReportList *reports, int index)
202 {
203         MTex *mtex;
204
205         if (index < 0 || index >= MAX_MTEX) {
206                 BKE_reportf(reports, RPT_ERROR, "Index %d is invalid", index);
207                 return NULL;
208         }
209
210         mtex = BKE_texture_mtex_add_id(self_id, index);
211
212         /* for redraw only */
213         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
214
215         return mtex;
216 }
217
218 void rna_mtex_texture_slots_clear(ID *self_id, struct bContext *C, ReportList *reports, int index)
219 {
220         MTex **mtex_ar;
221         short act;
222
223         give_active_mtex(self_id, &mtex_ar, &act);
224
225         if (mtex_ar == NULL) {
226                 BKE_report(reports, RPT_ERROR, "Mtex not found for this type");
227                 return;
228         }
229
230         if (index < 0 || index >= MAX_MTEX) {
231                 BKE_reportf(reports, RPT_ERROR, "Index %d is invalid", index);
232                 return;
233         }
234
235         if (mtex_ar[index]) {
236                 id_us_min((ID *)mtex_ar[index]->tex);
237                 MEM_freeN(mtex_ar[index]);
238                 mtex_ar[index] = NULL;
239                 DEG_id_tag_update(self_id, 0);
240         }
241
242         /* for redraw only */
243         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
244 }
245
246 #else
247
248 static void rna_def_material_display(StructRNA *srna)
249 {
250         PropertyRNA *prop;
251
252         prop = RNA_def_property(srna, "diffuse_color", PROP_FLOAT, PROP_COLOR);
253         RNA_def_property_float_sdna(prop, NULL, "r");
254         RNA_def_property_array(prop, 3);
255         RNA_def_property_ui_text(prop, "Diffuse Color", "Diffuse color of the material");
256         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
257
258         prop = RNA_def_property(srna, "specular_color", PROP_FLOAT, PROP_COLOR);
259         RNA_def_property_float_sdna(prop, NULL, "specr");
260         RNA_def_property_array(prop, 3);
261         RNA_def_property_ui_text(prop, "Specular Color", "Specular color of the material");
262         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
263
264         prop = RNA_def_property(srna, "roughness", PROP_FLOAT, PROP_FACTOR);
265         RNA_def_property_float_sdna(prop, NULL, "roughness");
266         RNA_def_property_float_default(prop, 0.25f);
267         RNA_def_property_range(prop, 0, 1);
268         RNA_def_property_ui_text(prop, "Roughness", "Roughness of the material");
269         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
270
271         prop = RNA_def_property(srna, "specular_intensity", PROP_FLOAT, PROP_FACTOR);
272         RNA_def_property_float_sdna(prop, NULL, "spec");
273         RNA_def_property_float_default(prop, 0.5f);
274         RNA_def_property_range(prop, 0, 1);
275         RNA_def_property_ui_text(prop, "Specular", "How intense (bright) the specular reflection is");
276         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
277
278         prop = RNA_def_property(srna, "metallic", PROP_FLOAT, PROP_FACTOR);
279         RNA_def_property_float_sdna(prop, NULL, "metallic");
280         RNA_def_property_range(prop, 0.0f, 1.0f);
281         RNA_def_property_ui_text(prop, "Metallic", "Amount of mirror reflection for raytrace");
282         RNA_def_property_update(prop, 0, "rna_Material_update");
283
284         /* Freestyle line color */
285         prop = RNA_def_property(srna, "line_color", PROP_FLOAT, PROP_COLOR);
286         RNA_def_property_float_sdna(prop, NULL, "line_col");
287         RNA_def_property_array(prop, 4);
288         RNA_def_property_ui_text(prop, "Line Color", "Line color used for Freestyle line rendering");
289         RNA_def_property_update(prop, 0, "rna_Material_update");
290
291         prop = RNA_def_property(srna, "line_priority", PROP_INT, PROP_NONE);
292         RNA_def_property_int_sdna(prop, NULL, "line_priority");
293         RNA_def_property_range(prop, 0, 32767);
294         RNA_def_property_ui_text(prop, "Line Priority",
295                                  "The line color of a higher priority is used at material boundaries");
296         RNA_def_property_update(prop, 0, "rna_Material_update");
297 }
298
299 void RNA_def_material(BlenderRNA *brna)
300 {
301         StructRNA *srna;
302         PropertyRNA *prop;
303
304         /* Render Preview Types */
305         static const EnumPropertyItem preview_type_items[] = {
306                 {MA_FLAT, "FLAT", ICON_MATPLANE, "Flat", "Flat XY plane"},
307                 {MA_SPHERE, "SPHERE", ICON_MATSPHERE, "Sphere", "Sphere"},
308                 {MA_CUBE, "CUBE", ICON_MATCUBE, "Cube", "Cube"},
309                 {MA_MONKEY, "MONKEY", ICON_MONKEY, "Monkey", "Monkey"},
310                 {MA_HAIR, "HAIR", ICON_HAIR, "Hair", "Hair strands"},
311                 {MA_SPHERE_A, "SPHERE_A", ICON_MAT_SPHERE_SKY, "World Sphere", "Large sphere with sky"},
312                 {0, NULL, 0, NULL, NULL}
313         };
314
315         static EnumPropertyItem prop_eevee_blend_items[] = {
316                 {MA_BM_SOLID, "OPAQUE", 0, "Opaque", "Render surface without transparency"},
317                 {MA_BM_ADD, "ADD", 0, "Additive", "Render surface and blend the result with additive blending"},
318                 {MA_BM_MULTIPLY, "MULTIPLY", 0, "Multiply", "Render surface and blend the result with multiplicative blending"},
319                 {MA_BM_CLIP, "CLIP", 0, "Alpha Clip", "Use the alpha threshold to clip the visibility (binary visibility)"},
320                 {MA_BM_HASHED, "HASHED", 0, "Alpha Hashed", "Use noise to dither the binary visibility (works well with multi-samples)"},
321                 {MA_BM_BLEND, "BLEND", 0, "Alpha Blend", "Render polygon transparent, depending on alpha channel of the texture"},
322                 {0, NULL, 0, NULL, NULL}
323         };
324
325         static EnumPropertyItem prop_eevee_blend_shadow_items[] = {
326                 {MA_BS_NONE, "NONE", 0, "None", "Material will cast no shadow"},
327                 {MA_BS_SOLID, "OPAQUE", 0, "Opaque", "Material will cast shadows without transparency"},
328                 {MA_BS_CLIP, "CLIP", 0, "Clip", "Use the alpha threshold to clip the visibility (binary visibility)"},
329                 {MA_BS_HASHED, "HASHED", 0, "Hashed", "Use noise to dither the binary visibility and use filtering to reduce the noise"},
330                 {0, NULL, 0, NULL, NULL}
331         };
332
333         srna = RNA_def_struct(brna, "Material", "ID");
334         RNA_def_struct_ui_text(srna, "Material",
335                                "Material data-block to define the appearance of geometric objects for rendering");
336         RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
337
338         /* Blending (only Eevee for now) */
339         prop = RNA_def_property(srna, "blend_method", PROP_ENUM, PROP_NONE);
340         RNA_def_property_enum_items(prop, prop_eevee_blend_items);
341         RNA_def_property_ui_text(prop, "Blend Mode", "Blend Mode for Transparent Faces");
342         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
343
344         prop = RNA_def_property(srna, "transparent_shadow_method", PROP_ENUM, PROP_NONE);
345         RNA_def_property_enum_sdna(prop, NULL, "blend_shadow");
346         RNA_def_property_enum_items(prop, prop_eevee_blend_shadow_items);
347         RNA_def_property_ui_text(prop, "Transparent Shadow", "Shadow method for transparent material");
348         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
349
350         prop = RNA_def_property(srna, "alpha_threshold", PROP_FLOAT, PROP_FACTOR);
351         RNA_def_property_range(prop, 0, 1);
352         RNA_def_property_ui_text(prop, "Clip Threshold", "A pixel is rendered only if its alpha value is above this threshold");
353         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
354
355         prop = RNA_def_property(srna, "show_transparent_backside", PROP_BOOLEAN, PROP_NONE);
356         RNA_def_property_boolean_negative_sdna(prop, NULL, "blend_flag", MA_BL_HIDE_BACKSIDE);
357         RNA_def_property_ui_text(prop, "Show Backside", "Limit transparency to a single layer "
358                                                          "(avoids transparency sorting problems)");
359         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
360
361         prop = RNA_def_property(srna, "use_screen_refraction", PROP_BOOLEAN, PROP_NONE);
362         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MA_BL_SS_REFRACTION);
363         RNA_def_property_ui_text(prop, "Screen Space Refraction", "Use raytraced screen space refractions");
364         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
365
366         prop = RNA_def_property(srna, "use_screen_subsurface", PROP_BOOLEAN, PROP_NONE);
367         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MA_BL_SS_SUBSURFACE);
368         RNA_def_property_ui_text(prop, "Screen Space Subsurface Scattering", "Use post process subsurface scattering");
369         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
370
371         prop = RNA_def_property(srna, "use_sss_translucency", PROP_BOOLEAN, PROP_NONE);
372         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MA_BL_TRANSLUCENCY);
373         RNA_def_property_ui_text(prop, "Subsurface Translucency", "Add translucency effect to subsurface");
374         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
375
376         prop = RNA_def_property(srna, "refraction_depth", PROP_FLOAT, PROP_DISTANCE);
377         RNA_def_property_float_sdna(prop, NULL, "refract_depth");
378         RNA_def_property_range(prop, 0.0f, FLT_MAX);
379         RNA_def_property_ui_text(prop, "Refraction Depth", "Approximate the thickness of the object to compute two refraction "
380                                                            "event (0 is disabled)");
381         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
382
383         /* For Preview Render */
384         prop = RNA_def_property(srna, "preview_render_type", PROP_ENUM, PROP_NONE);
385         RNA_def_property_enum_sdna(prop, NULL, "pr_type");
386         RNA_def_property_enum_items(prop, preview_type_items);
387         RNA_def_property_ui_text(prop, "Preview render type", "Type of preview render");
388         RNA_def_property_update(prop, 0, "rna_Material_update_previews");
389
390         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
391         RNA_def_property_int_sdna(prop, NULL, "index");
392         RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Material Index\" render pass");
393         RNA_def_property_update(prop, NC_OBJECT, "rna_Material_update");
394
395         /* nodetree */
396         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
397         RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
398         RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based materials");
399
400         prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
401         RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1);
402         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
403         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
404         RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the material");
405         RNA_def_property_update(prop, 0, "rna_Material_use_nodes_update");
406
407         /* common */
408         rna_def_animdata_common(srna);
409         rna_def_texpaint_slots(brna, srna);
410
411         rna_def_material_display(srna);
412
413         RNA_api_material(srna);
414 }
415
416
417 static void rna_def_texture_slots(BlenderRNA *brna, PropertyRNA *cprop, const char *structname,
418                                   const char *structname_slots)
419 {
420         StructRNA *srna;
421
422         FunctionRNA *func;
423         PropertyRNA *parm;
424
425         RNA_def_property_srna(cprop, structname_slots);
426         srna = RNA_def_struct(brna, structname_slots, NULL);
427         RNA_def_struct_sdna(srna, "ID");
428         RNA_def_struct_ui_text(srna, "Texture Slots", "Collection of texture slots");
429
430         /* functions */
431         func = RNA_def_function(srna, "add", "rna_mtex_texture_slots_add");
432         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
433         parm = RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex");
434         RNA_def_function_return(func, parm);
435
436         func = RNA_def_function(srna, "create", "rna_mtex_texture_slots_create");
437         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
438         parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to initialize", 0, INT_MAX);
439         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
440         parm = RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex");
441         RNA_def_function_return(func, parm);
442
443         func = RNA_def_function(srna, "clear", "rna_mtex_texture_slots_clear");
444         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
445         parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to clear", 0, INT_MAX);
446         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
447 }
448
449 void rna_def_mtex_common(BlenderRNA *brna, StructRNA *srna, const char *begin,
450                          const char *activeget, const char *activeset, const char *activeeditable,
451                          const char *structname, const char *structname_slots, const char *update, const char *update_index)
452 {
453         PropertyRNA *prop;
454
455         /* mtex */
456         prop = RNA_def_property(srna, "texture_slots", PROP_COLLECTION, PROP_NONE);
457         RNA_def_property_struct_type(prop, structname);
458         RNA_def_property_collection_funcs(prop, begin, "rna_iterator_array_next", "rna_iterator_array_end",
459                                           "rna_iterator_array_dereference_get", NULL, NULL, NULL, NULL);
460         RNA_def_property_ui_text(prop, "Textures", "Texture slots defining the mapping and influence of textures");
461         rna_def_texture_slots(brna, prop, structname, structname_slots);
462
463         prop = RNA_def_property(srna, "active_texture", PROP_POINTER, PROP_NONE);
464         RNA_def_property_struct_type(prop, "Texture");
465         RNA_def_property_flag(prop, PROP_EDITABLE);
466         if (activeeditable)
467                 RNA_def_property_editable_func(prop, activeeditable);
468         RNA_def_property_pointer_funcs(prop, activeget, activeset, NULL, NULL);
469         RNA_def_property_ui_text(prop, "Active Texture", "Active texture slot being displayed");
470         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, update);
471
472         prop = RNA_def_property(srna, "active_texture_index", PROP_INT, PROP_UNSIGNED);
473         RNA_def_property_int_sdna(prop, NULL, "texact");
474         RNA_def_property_range(prop, 0, MAX_MTEX - 1);
475         RNA_def_property_ui_text(prop, "Active Texture Index", "Index of active texture slot");
476         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, update_index);
477 }
478
479 static void rna_def_tex_slot(BlenderRNA *brna)
480 {
481         StructRNA *srna;
482         PropertyRNA *prop;
483
484         srna = RNA_def_struct(brna, "TexPaintSlot", NULL);
485         RNA_def_struct_ui_text(srna, "Texture Paint Slot",
486                                "Slot that contains information about texture painting");
487
488         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
489         RNA_def_property_string_maxlength(prop, 64); /* else it uses the pointer size! */
490         RNA_def_property_string_sdna(prop, NULL, "uvname");
491         RNA_def_property_ui_text(prop, "UV Map", "Name of UV map");
492         RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Material_update");
493
494         prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
495         RNA_def_property_boolean_sdna(prop, NULL, "valid", 1);
496         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
497         RNA_def_property_ui_text(prop, "Valid", "Slot has a valid image and UV map");
498 }
499
500
501 void rna_def_texpaint_slots(BlenderRNA *brna, StructRNA *srna)
502 {
503         PropertyRNA *prop;
504
505         rna_def_tex_slot(brna);
506
507         /* mtex */
508         prop = RNA_def_property(srna, "texture_paint_images", PROP_COLLECTION, PROP_NONE);
509         RNA_def_property_collection_sdna(prop, NULL, "texpaintslot", NULL);
510         RNA_def_property_collection_funcs(prop, "rna_Material_texpaint_begin", "rna_iterator_array_next", "rna_iterator_array_end",
511                                           "rna_iterator_array_dereference_get", NULL, NULL, NULL, NULL);
512         RNA_def_property_struct_type(prop, "Image");
513         RNA_def_property_ui_text(prop, "Texture Slot Images", "Texture images used for texture painting");
514
515         prop = RNA_def_property(srna, "texture_paint_slots", PROP_COLLECTION, PROP_NONE);
516         RNA_def_property_collection_funcs(prop, "rna_Material_texpaint_begin", "rna_iterator_array_next", "rna_iterator_array_end",
517                                           "rna_iterator_array_get", NULL, NULL, NULL, NULL);
518         RNA_def_property_struct_type(prop, "TexPaintSlot");
519         RNA_def_property_ui_text(prop, "Texture Slots", "Texture slots defining the mapping and influence of textures");
520
521         prop = RNA_def_property(srna, "paint_active_slot", PROP_INT, PROP_UNSIGNED);
522         RNA_def_property_range(prop, 0, SHRT_MAX);
523         RNA_def_property_ui_text(prop, "Active Paint Texture Index", "Index of active texture paint slot");
524         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, "rna_Material_active_paint_texture_index_update");
525
526         prop = RNA_def_property(srna, "paint_clone_slot", PROP_INT, PROP_UNSIGNED);
527         RNA_def_property_range(prop, 0, SHRT_MAX);
528         RNA_def_property_ui_text(prop, "Clone Paint Texture Index", "Index of clone texture paint slot");
529         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, NULL);
530 }
531
532 #endif