Cleanup: indentation
[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         {0, "", ICON_NONE, NULL, NULL},
44         {MA_RAMP_DARK, "DARKEN", 0, "Darken", ""},
45         {MA_RAMP_MULT, "MULTIPLY", 0, "Multiply", ""},
46         {MA_RAMP_BURN, "BURN", 0, "Burn", ""},
47         {0, "", ICON_NONE, NULL, NULL},
48         {MA_RAMP_LIGHT, "LIGHTEN", 0, "Lighten", ""},
49         {MA_RAMP_SCREEN, "SCREEN", 0, "Screen", ""},
50         {MA_RAMP_DODGE, "DODGE", 0, "Dodge", ""},
51         {MA_RAMP_ADD, "ADD", 0, "Add", ""},
52         {0, "", ICON_NONE, NULL, NULL},
53         {MA_RAMP_OVERLAY, "OVERLAY", 0, "Overlay", ""},
54         {MA_RAMP_SOFT, "SOFT_LIGHT", 0, "Soft Light", ""},
55         {MA_RAMP_LINEAR, "LINEAR_LIGHT", 0, "Linear Light", ""},
56         {0, "", ICON_NONE, NULL, NULL},
57         {MA_RAMP_DIFF, "DIFFERENCE", 0, "Difference", ""},
58         {MA_RAMP_SUB, "SUBTRACT", 0, "Subtract", ""},
59         {MA_RAMP_DIV, "DIVIDE", 0, "Divide", ""},
60         {0, "", ICON_NONE, NULL, NULL},
61         {MA_RAMP_HUE, "HUE", 0, "Hue", ""},
62         {MA_RAMP_SAT, "SATURATION", 0, "Saturation", ""},
63         {MA_RAMP_COLOR, "COLOR", 0, "Color", ""},
64         {MA_RAMP_VAL, "VALUE", 0, "Value", ""},
65         {0, NULL, 0, NULL, NULL}
66 };
67
68 #ifdef RNA_RUNTIME
69
70 #include "MEM_guardedalloc.h"
71
72 #include "DNA_node_types.h"
73 #include "DNA_object_types.h"
74 #include "DNA_screen_types.h"
75 #include "DNA_space_types.h"
76
77 #include "BKE_colorband.h"
78 #include "BKE_context.h"
79 #include "BKE_main.h"
80 #include "BKE_gpencil.h"
81 #include "BKE_material.h"
82 #include "BKE_texture.h"
83 #include "BKE_node.h"
84 #include "BKE_paint.h"
85 #include "BKE_scene.h"
86 #include "BKE_workspace.h"
87
88 #include "DEG_depsgraph.h"
89 #include "DEG_depsgraph_build.h"
90
91 #include "ED_node.h"
92 #include "ED_image.h"
93 #include "ED_screen.h"
94 #include "ED_gpencil.h"
95
96 static void rna_Material_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
97 {
98         Material *ma = ptr->id.data;
99
100         DEG_id_tag_update(&ma->id, DEG_TAG_COPY_ON_WRITE);
101         WM_main_add_notifier(NC_MATERIAL | ND_SHADING, ma);
102 }
103
104 static void rna_Material_update_previews(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
105 {
106         Material *ma = ptr->id.data;
107
108         if (ma->nodetree)
109                 BKE_node_preview_clear_tree(ma->nodetree);
110
111         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_PREVIEW, ma);
112 }
113
114 static void rna_MaterialGpencil_update(Main *bmain, Scene *scene, PointerRNA *ptr)
115 {
116         Material *ma = ptr->id.data;
117         PreviewImage *preview = ma->preview;
118
119         rna_Material_update(bmain, scene, ptr);
120
121         /* update previews (icon and thumbnail) */
122         if (preview != NULL) {
123                 bool changed = false;
124                 if ((preview->flag[ICON_SIZE_ICON] & PRV_CHANGED) == 0) {
125                         preview->flag[ICON_SIZE_ICON] |= PRV_CHANGED;
126                         changed = true;
127                 }
128
129                 if ((preview->flag[ICON_SIZE_PREVIEW] & PRV_CHANGED) == 0) {
130                         preview->flag[ICON_SIZE_PREVIEW] |= PRV_CHANGED;
131                         changed = true;
132                 }
133
134                 if (changed) {
135                         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_PREVIEW, ma);
136                 }
137         }
138         WM_main_add_notifier(NC_GPENCIL | ND_DATA, ma);
139 }
140
141 static void rna_MaterialGpencil_nopreview_update(Main *bmain, Scene *scene, PointerRNA *ptr)
142 {
143         Material *ma = ptr->id.data;
144
145         rna_Material_update(bmain, scene, ptr);
146
147         WM_main_add_notifier(NC_GPENCIL | ND_DATA, ma);
148 }
149
150 static void rna_Material_draw_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
151 {
152         Material *ma = ptr->id.data;
153
154         DEG_id_tag_update(&ma->id, DEG_TAG_COPY_ON_WRITE);
155         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, ma);
156 }
157
158 static void rna_Material_texpaint_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
159 {
160         Material *ma = (Material *)ptr->data;
161         rna_iterator_array_begin(iter, (void *)ma->texpaintslot, sizeof(TexPaintSlot), ma->tot_slots, 0, NULL);
162 }
163
164
165 static void rna_Material_active_paint_texture_index_update(Main *bmain, Scene *scene, PointerRNA *ptr)
166 {
167         bScreen *sc;
168         Material *ma = ptr->id.data;
169
170         if (ma->use_nodes && ma->nodetree) {
171                 struct bNode *node;
172                 int index = 0;
173                 for (node = ma->nodetree->nodes.first; node; node = node->next) {
174                         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE && node->typeinfo->type == SH_NODE_TEX_IMAGE && node->id) {
175                                 if (index++ == ma->paint_active_slot) {
176                                         break;
177                                 }
178                         }
179                 }
180                 if (node)
181                         nodeSetActive(ma->nodetree, node);
182         }
183
184         if (ma->texpaintslot) {
185                 Image *image = ma->texpaintslot[ma->paint_active_slot].ima;
186                 for (sc = bmain->screen.first; sc; sc = sc->id.next) {
187                         wmWindow *win = ED_screen_window_find(sc, bmain->wm.first);
188                         if (win == NULL) {
189                                 continue;
190                         }
191
192                         Object *obedit = NULL;
193                         {
194                                 ViewLayer *view_layer = WM_window_get_active_view_layer(win);
195                                 obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
196                         }
197
198                         ScrArea *sa;
199                         for (sa = sc->areabase.first; sa; sa = sa->next) {
200                                 SpaceLink *sl;
201                                 for (sl = sa->spacedata.first; sl; sl = sl->next) {
202                                         if (sl->spacetype == SPACE_IMAGE) {
203                                                 SpaceImage *sima = (SpaceImage *)sl;
204                                                 if (!sima->pin) {
205                                                         ED_space_image_set(bmain, sima, scene, obedit, image);
206                                                 }
207                                         }
208                                 }
209                         }
210                 }
211         }
212
213         DEG_id_tag_update(&ma->id, 0);
214         WM_main_add_notifier(NC_MATERIAL | ND_SHADING, ma);
215 }
216
217 static void rna_Material_use_nodes_update(bContext *C, PointerRNA *ptr)
218 {
219         Material *ma = (Material *)ptr->data;
220         Main *bmain = CTX_data_main(C);
221
222         if (ma->use_nodes && ma->nodetree == NULL)
223                 ED_node_shader_default(C, &ma->id);
224
225         DEG_id_tag_update(&ma->id, DEG_TAG_COPY_ON_WRITE);
226         DEG_relations_tag_update(bmain);
227         rna_Material_draw_update(bmain, CTX_data_scene(C), ptr);
228 }
229
230 MTex *rna_mtex_texture_slots_add(ID *self_id, struct bContext *C, ReportList *reports)
231 {
232         MTex *mtex = BKE_texture_mtex_add_id(self_id, -1);
233         if (mtex == NULL) {
234                 BKE_reportf(reports, RPT_ERROR, "Maximum number of textures added %d", MAX_MTEX);
235                 return NULL;
236         }
237
238         /* for redraw only */
239         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
240
241         return mtex;
242 }
243
244 MTex *rna_mtex_texture_slots_create(ID *self_id, struct bContext *C, ReportList *reports, int index)
245 {
246         MTex *mtex;
247
248         if (index < 0 || index >= MAX_MTEX) {
249                 BKE_reportf(reports, RPT_ERROR, "Index %d is invalid", index);
250                 return NULL;
251         }
252
253         mtex = BKE_texture_mtex_add_id(self_id, index);
254
255         /* for redraw only */
256         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
257
258         return mtex;
259 }
260
261 void rna_mtex_texture_slots_clear(ID *self_id, struct bContext *C, ReportList *reports, int index)
262 {
263         MTex **mtex_ar;
264         short act;
265
266         give_active_mtex(self_id, &mtex_ar, &act);
267
268         if (mtex_ar == NULL) {
269                 BKE_report(reports, RPT_ERROR, "Mtex not found for this type");
270                 return;
271         }
272
273         if (index < 0 || index >= MAX_MTEX) {
274                 BKE_reportf(reports, RPT_ERROR, "Index %d is invalid", index);
275                 return;
276         }
277
278         if (mtex_ar[index]) {
279                 id_us_min((ID *)mtex_ar[index]->tex);
280                 MEM_freeN(mtex_ar[index]);
281                 mtex_ar[index] = NULL;
282                 DEG_id_tag_update(self_id, 0);
283         }
284
285         /* for redraw only */
286         WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
287 }
288
289 static void rna_TexPaintSlot_uv_layer_get(PointerRNA *ptr, char *value)
290 {
291         TexPaintSlot *data = (TexPaintSlot *)(ptr->data);
292
293         if (data->uvname != NULL) {
294                 BLI_strncpy_utf8(value, data->uvname, 64);
295         }
296         else {
297                 value[0] = '\0';
298         }
299 }
300
301 static int rna_TexPaintSlot_uv_layer_length(PointerRNA *ptr)
302 {
303         TexPaintSlot *data = (TexPaintSlot *)(ptr->data);
304         return data->uvname == NULL ? 0 : strlen(data->uvname);
305 }
306
307 static void rna_TexPaintSlot_uv_layer_set(PointerRNA *ptr, const char *value)
308 {
309         TexPaintSlot *data = (TexPaintSlot *)(ptr->data);
310
311         if (data->uvname != NULL) {
312                 BLI_strncpy_utf8(data->uvname, value, 64);
313         }
314 }
315
316 static bool rna_is_grease_pencil_get(PointerRNA *ptr)
317 {
318         Material *ma = (Material *)ptr->data;
319         if (ma->gp_style != NULL)
320                 return true;
321
322         return false;
323 }
324
325 static void rna_gpcolordata_uv_update(Main *bmain, Scene *scene, PointerRNA *ptr)
326 {
327         /* update all uv strokes of this color */
328         Material *ma = ptr->id.data;
329         ED_gpencil_update_color_uv(bmain, ma);
330
331         rna_MaterialGpencil_update(bmain, scene, ptr);
332 }
333
334 static char *rna_GpencilColorData_path(PointerRNA *UNUSED(ptr))
335 {
336         return BLI_sprintfN("grease_pencil");
337 }
338
339 static int rna_GpencilColorData_is_stroke_visible_get(PointerRNA *ptr)
340 {
341         MaterialGPencilStyle *pcolor = ptr->data;
342         return (pcolor->stroke_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH);
343 }
344
345 static int rna_GpencilColorData_is_fill_visible_get(PointerRNA *ptr)
346 {
347         MaterialGPencilStyle *pcolor = (MaterialGPencilStyle *)ptr->data;
348         return ((pcolor->fill_rgba[3] > GPENCIL_ALPHA_OPACITY_THRESH) || (pcolor->fill_style > 0));
349 }
350
351 static void rna_GpencilColorData_stroke_image_set(PointerRNA *ptr, PointerRNA value)
352 {
353         MaterialGPencilStyle *pcolor = ptr->data;
354         ID *id = value.data;
355
356         id_us_plus(id);
357         pcolor->sima = (struct Image *)id;
358 }
359
360 static void rna_GpencilColorData_fill_image_set(PointerRNA *ptr, PointerRNA value)
361 {
362         MaterialGPencilStyle *pcolor = (MaterialGPencilStyle *)ptr->data;
363         ID *id = value.data;
364
365         id_us_plus(id);
366         pcolor->ima = (struct Image *)id;
367 }
368
369 #else
370
371 static void rna_def_material_display(StructRNA *srna)
372 {
373         PropertyRNA *prop;
374
375         prop = RNA_def_property(srna, "diffuse_color", PROP_FLOAT, PROP_COLOR);
376         RNA_def_property_float_sdna(prop, NULL, "r");
377         RNA_def_property_array(prop, 3);
378         RNA_def_property_ui_text(prop, "Diffuse Color", "Diffuse color of the material");
379         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
380
381         prop = RNA_def_property(srna, "specular_color", PROP_FLOAT, PROP_COLOR);
382         RNA_def_property_float_sdna(prop, NULL, "specr");
383         RNA_def_property_array(prop, 3);
384         RNA_def_property_ui_text(prop, "Specular Color", "Specular color of the material");
385         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
386
387         prop = RNA_def_property(srna, "roughness", PROP_FLOAT, PROP_FACTOR);
388         RNA_def_property_float_sdna(prop, NULL, "roughness");
389         RNA_def_property_float_default(prop, 0.25f);
390         RNA_def_property_range(prop, 0, 1);
391         RNA_def_property_ui_text(prop, "Roughness", "Roughness of the material");
392         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
393
394         prop = RNA_def_property(srna, "specular_intensity", PROP_FLOAT, PROP_FACTOR);
395         RNA_def_property_float_sdna(prop, NULL, "spec");
396         RNA_def_property_float_default(prop, 0.5f);
397         RNA_def_property_range(prop, 0, 1);
398         RNA_def_property_ui_text(prop, "Specular", "How intense (bright) the specular reflection is");
399         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
400
401         prop = RNA_def_property(srna, "metallic", PROP_FLOAT, PROP_FACTOR);
402         RNA_def_property_float_sdna(prop, NULL, "metallic");
403         RNA_def_property_range(prop, 0.0f, 1.0f);
404         RNA_def_property_ui_text(prop, "Metallic", "Amount of mirror reflection for raytrace");
405         RNA_def_property_update(prop, 0, "rna_Material_update");
406
407         /* Freestyle line color */
408         prop = RNA_def_property(srna, "line_color", PROP_FLOAT, PROP_COLOR);
409         RNA_def_property_float_sdna(prop, NULL, "line_col");
410         RNA_def_property_array(prop, 4);
411         RNA_def_property_ui_text(prop, "Line Color", "Line color used for Freestyle line rendering");
412         RNA_def_property_update(prop, 0, "rna_Material_update");
413
414         prop = RNA_def_property(srna, "line_priority", PROP_INT, PROP_NONE);
415         RNA_def_property_int_sdna(prop, NULL, "line_priority");
416         RNA_def_property_range(prop, 0, 32767);
417         RNA_def_property_ui_text(prop, "Line Priority",
418                                  "The line color of a higher priority is used at material boundaries");
419         RNA_def_property_update(prop, 0, "rna_Material_update");
420 }
421
422 static void rna_def_material_greasepencil(BlenderRNA *brna)
423 {
424         StructRNA *srna;
425         PropertyRNA *prop;
426
427         /* mode type styles */
428         static EnumPropertyItem gpcolordata_mode_types_items[] = {
429                 { GP_STYLE_MODE_LINE, "LINE", 0, "Line", "Draw strokes using a continuous line" },
430                 { GP_STYLE_MODE_DOTS, "DOTS", 0, "Dots", "Draw strokes using separated dots" },
431                 { GP_STYLE_MODE_BOX, "BOX", 0, "Boxes", "Draw strokes using separated rectangle boxes" },
432                 { 0, NULL, 0, NULL, NULL }
433         };
434
435         /* stroke styles */
436         static EnumPropertyItem stroke_style_items[] = {
437                 { GP_STYLE_STROKE_STYLE_SOLID, "SOLID", 0, "Solid", "Draw strokes with solid color" },
438                 { GP_STYLE_STROKE_STYLE_TEXTURE, "TEXTURE", 0, "Texture", "Draw strokes using texture" },
439                 { 0, NULL, 0, NULL, NULL }
440         };
441
442         /* fill styles */
443         static EnumPropertyItem fill_style_items[] = {
444                 { GP_STYLE_FILL_STYLE_SOLID, "SOLID", 0, "Solid", "Fill area with solid color" },
445                 { GP_STYLE_FILL_STYLE_GRADIENT, "GRADIENT", 0, "Gradient", "Fill area with gradient color" },
446                 { GP_STYLE_FILL_STYLE_CHESSBOARD, "CHESSBOARD", 0, "Checker Board", "Fill area with chessboard pattern" },
447                 { GP_STYLE_FILL_STYLE_TEXTURE, "TEXTURE", 0, "Texture", "Fill area with image texture" },
448                 { 0, NULL, 0, NULL, NULL }
449         };
450
451         static EnumPropertyItem fill_gradient_items[] = {
452                 { GP_STYLE_GRADIENT_LINEAR, "LINEAR", 0, "Linear", "Fill area with gradient color" },
453                 { GP_STYLE_GRADIENT_RADIAL, "RADIAL", 0, "Radial", "Fill area with radial gradient" },
454                 { 0, NULL, 0, NULL, NULL }
455         };
456
457         srna = RNA_def_struct(brna, "MaterialGPencilStyle", NULL);
458         RNA_def_struct_sdna(srna, "MaterialGPencilStyle");
459         RNA_def_struct_ui_text(srna, "Grease Pencil Color", "");
460         RNA_def_struct_path_func(srna, "rna_GpencilColorData_path");
461
462         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
463         RNA_def_property_range(prop, 0.0, 1.0);
464         RNA_def_property_float_sdna(prop, NULL, "stroke_rgba");
465         RNA_def_property_array(prop, 4);
466         RNA_def_property_ui_text(prop, "Color", "");
467         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
468
469         /* Fill Drawing Color */
470         prop = RNA_def_property(srna, "fill_color", PROP_FLOAT, PROP_COLOR_GAMMA);
471         RNA_def_property_float_sdna(prop, NULL, "fill_rgba");
472         RNA_def_property_array(prop, 4);
473         RNA_def_property_range(prop, 0.0f, 1.0f);
474         RNA_def_property_ui_text(prop, "Fill Color", "Color for filling region bounded by each stroke");
475         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
476
477         /* Secondary Drawing Color */
478         prop = RNA_def_property(srna, "mix_color", PROP_FLOAT, PROP_COLOR_GAMMA);
479         RNA_def_property_float_sdna(prop, NULL, "mix_rgba");
480         RNA_def_property_array(prop, 4);
481         RNA_def_property_range(prop, 0.0f, 1.0f);
482         RNA_def_property_ui_text(prop, "Mix Color", "Color for mixing with primary filling color");
483         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
484
485         /* Mix factor */
486         prop = RNA_def_property(srna, "mix_factor", PROP_FLOAT, PROP_NONE);
487         RNA_def_property_float_sdna(prop, NULL, "mix_factor");
488         RNA_def_property_range(prop, 0.0f, 1.0f);
489         RNA_def_property_ui_text(prop, "Mix", "Mix Adjustment Factor");
490         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
491
492         /* Scale factor for uv coordinates */
493         prop = RNA_def_property(srna, "pattern_scale", PROP_FLOAT, PROP_COORDS);
494         RNA_def_property_float_sdna(prop, NULL, "gradient_scale");
495         RNA_def_property_array(prop, 2);
496         RNA_def_property_ui_text(prop, "Scale", "Scale Factor for UV coordinates");
497         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
498
499         /* Shift factor to move pattern filling in 2d space */
500         prop = RNA_def_property(srna, "pattern_shift", PROP_FLOAT, PROP_COORDS);
501         RNA_def_property_float_sdna(prop, NULL, "gradient_shift");
502         RNA_def_property_array(prop, 2);
503         RNA_def_property_ui_text(prop, "Shift", "Shift filling pattern in 2d space");
504         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
505
506         /* Gradient angle */
507         prop = RNA_def_property(srna, "pattern_angle", PROP_FLOAT, PROP_ANGLE);
508         RNA_def_property_float_sdna(prop, NULL, "gradient_angle");
509         RNA_def_property_ui_text(prop, "Angle", "Pattern Orientation Angle");
510         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
511
512         /* Gradient radius */
513         prop = RNA_def_property(srna, "pattern_radius", PROP_FLOAT, PROP_NONE);
514         RNA_def_property_float_sdna(prop, NULL, "gradient_radius");
515         RNA_def_property_range(prop, 0.0001f, 10.0f);
516         RNA_def_property_ui_text(prop, "Radius", "Pattern Radius");
517         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
518
519         /* Box size */
520         prop = RNA_def_property(srna, "pattern_gridsize", PROP_FLOAT, PROP_NONE);
521         RNA_def_property_float_sdna(prop, NULL, "pattern_gridsize");
522         RNA_def_property_range(prop, 0.0001f, 10.0f);
523         RNA_def_property_ui_text(prop, "Size", "Box Size");
524         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
525
526         /* Texture angle */
527         prop = RNA_def_property(srna, "texture_angle", PROP_FLOAT, PROP_ANGLE);
528         RNA_def_property_float_sdna(prop, NULL, "texture_angle");
529         RNA_def_property_ui_text(prop, "Angle", "Texture Orientation Angle");
530         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
531
532         /* Scale factor for texture */
533         prop = RNA_def_property(srna, "texture_scale", PROP_FLOAT, PROP_COORDS);
534         RNA_def_property_float_sdna(prop, NULL, "texture_scale");
535         RNA_def_property_array(prop, 2);
536         RNA_def_property_ui_text(prop, "Scale", "Scale Factor for Texture");
537         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
538
539         /* Shift factor to move texture in 2d space */
540         prop = RNA_def_property(srna, "texture_offset", PROP_FLOAT, PROP_COORDS);
541         RNA_def_property_float_sdna(prop, NULL, "texture_offset");
542         RNA_def_property_array(prop, 2);
543         RNA_def_property_ui_text(prop, "Offset", "Shift Texture in 2d Space");
544         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
545
546         /* Texture opacity size */
547         prop = RNA_def_property(srna, "texture_opacity", PROP_FLOAT, PROP_NONE);
548         RNA_def_property_float_sdna(prop, NULL, "texture_opacity");
549         RNA_def_property_range(prop, 0.0f, 1.0f);
550         RNA_def_property_ui_text(prop, "Opacity", "Texture Opacity");
551         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
552
553         /* texture pixsize factor (used for UV along the stroke) */
554         prop = RNA_def_property(srna, "pixel_size", PROP_FLOAT, PROP_NONE);
555         RNA_def_property_float_sdna(prop, NULL, "texture_pixsize");
556         RNA_def_property_range(prop, 1, 5000);
557         RNA_def_property_ui_text(prop, "UV Factor", "Texture Pixel Size factor along the stroke");
558         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_gpcolordata_uv_update");
559
560         /* Flags */
561         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
562         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_HIDE);
563         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
564         RNA_def_property_ui_text(prop, "Hide", "Set color Visibility");
565         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_nopreview_update");
566
567         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
568         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_LOCKED);
569         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
570         RNA_def_property_ui_text(prop, "Locked", "Protect color from further editing and/or frame changes");
571         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_nopreview_update");
572
573         prop = RNA_def_property(srna, "ghost", PROP_BOOLEAN, PROP_NONE);
574         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_ONIONSKIN);
575         RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
576         RNA_def_property_ui_text(prop, "Show in Ghosts", "Display strokes using this color when showing onion skins");
577         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_nopreview_update");
578
579         prop = RNA_def_property(srna, "texture_clamp", PROP_BOOLEAN, PROP_NONE);
580         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_TEX_CLAMP);
581         RNA_def_property_ui_text(prop, "Clamp", "Do not repeat texture and clamp to one instance only");
582         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
583
584         prop = RNA_def_property(srna, "texture_mix", PROP_BOOLEAN, PROP_NONE);
585         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_TEX_MIX);
586         RNA_def_property_ui_text(prop, "Mix Texture", "Mix texture image with filling colors");
587         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
588
589         prop = RNA_def_property(srna, "flip", PROP_BOOLEAN, PROP_NONE);
590         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_COLOR_FLIP_FILL);
591         RNA_def_property_ui_text(prop, "Flip", "Flip filling colors");
592         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
593
594         prop = RNA_def_property(srna, "use_stroke_pattern", PROP_BOOLEAN, PROP_NONE);
595         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_STROKE_PATTERN);
596         RNA_def_property_ui_text(prop, "Pattern", "Use Stroke Texture as a pattern to apply color");
597         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
598
599         prop = RNA_def_property(srna, "use_fill_pattern", PROP_BOOLEAN, PROP_NONE);
600         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STYLE_FILL_PATTERN);
601         RNA_def_property_ui_text(prop, "Pattern", "Use Fill Texture as a pattern to apply color");
602         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
603
604         /* pass index for future compositing and editing tools */
605         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
606         RNA_def_property_int_sdna(prop, NULL, "index");
607         RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Color Index\" pass");
608         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_nopreview_update");
609
610         /* mode type */
611         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
612         RNA_def_property_enum_bitflag_sdna(prop, NULL, "mode");
613         RNA_def_property_enum_items(prop, gpcolordata_mode_types_items);
614         RNA_def_property_ui_text(prop, "Mode Type", "Select draw mode for stroke");
615         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
616
617         /* stroke style */
618         prop = RNA_def_property(srna, "stroke_style", PROP_ENUM, PROP_NONE);
619         RNA_def_property_enum_bitflag_sdna(prop, NULL, "stroke_style");
620         RNA_def_property_enum_items(prop, stroke_style_items);
621         RNA_def_property_ui_text(prop, "Stroke Style", "Select style used to draw strokes");
622         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
623
624         /* stroke image texture */
625         prop = RNA_def_property(srna, "stroke_image", PROP_POINTER, PROP_NONE);
626         RNA_def_property_pointer_sdna(prop, NULL, "sima");
627         RNA_def_property_pointer_funcs(prop, NULL, "rna_GpencilColorData_stroke_image_set", NULL, NULL);
628         RNA_def_property_flag(prop, PROP_EDITABLE);
629         RNA_def_property_ui_text(prop, "Image", "");
630         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
631
632         /* fill style */
633         prop = RNA_def_property(srna, "fill_style", PROP_ENUM, PROP_NONE);
634         RNA_def_property_enum_bitflag_sdna(prop, NULL, "fill_style");
635         RNA_def_property_enum_items(prop, fill_style_items);
636         RNA_def_property_ui_text(prop, "Fill Style", "Select style used to fill strokes");
637         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
638
639         /* gradient type */
640         prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
641         RNA_def_property_enum_bitflag_sdna(prop, NULL, "gradient_type");
642         RNA_def_property_enum_items(prop, fill_gradient_items);
643         RNA_def_property_ui_text(prop, "Gradient Type", "Select type of gradient used to fill strokes");
644         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
645
646         /* fill image texture */
647         prop = RNA_def_property(srna, "fill_image", PROP_POINTER, PROP_NONE);
648         RNA_def_property_pointer_sdna(prop, NULL, "ima");
649         RNA_def_property_pointer_funcs(prop, NULL, "rna_GpencilColorData_fill_image_set", NULL, NULL);
650         RNA_def_property_flag(prop, PROP_EDITABLE);
651         RNA_def_property_ui_text(prop, "Image", "");
652         RNA_def_property_update(prop, NC_GPENCIL | ND_SHADING, "rna_MaterialGpencil_update");
653
654         /* Read-only state props (for simpler UI code) */
655         prop = RNA_def_property(srna, "is_stroke_visible", PROP_BOOLEAN, PROP_NONE);
656         RNA_def_property_boolean_funcs(prop, "rna_GpencilColorData_is_stroke_visible_get", NULL);
657         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
658         RNA_def_property_ui_text(prop, "Is Stroke Visible", "True when opacity of stroke is set high enough to be visible");
659
660         prop = RNA_def_property(srna, "is_fill_visible", PROP_BOOLEAN, PROP_NONE);
661         RNA_def_property_boolean_funcs(prop, "rna_GpencilColorData_is_fill_visible_get", NULL);
662         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
663         RNA_def_property_ui_text(prop, "Is Fill Visible", "True when opacity of fill is set high enough to be visible");
664
665 }
666
667 void RNA_def_material(BlenderRNA *brna)
668 {
669         StructRNA *srna;
670         PropertyRNA *prop;
671
672         /* Render Preview Types */
673         static const EnumPropertyItem preview_type_items[] = {
674                 {MA_FLAT, "FLAT", ICON_MATPLANE, "Flat", "Flat XY plane"},
675                 {MA_SPHERE, "SPHERE", ICON_MATSPHERE, "Sphere", "Sphere"},
676                 {MA_CUBE, "CUBE", ICON_MATCUBE, "Cube", "Cube"},
677                 {MA_MONKEY, "MONKEY", ICON_MONKEY, "Monkey", "Monkey"},
678                 {MA_HAIR, "HAIR", ICON_HAIR, "Hair", "Hair strands"},
679                 {MA_SPHERE_A, "SPHERE_A", ICON_MAT_SPHERE_SKY, "World Sphere", "Large sphere with sky"},
680                 {0, NULL, 0, NULL, NULL}
681         };
682
683         static EnumPropertyItem prop_eevee_blend_items[] = {
684                 {MA_BM_SOLID, "OPAQUE", 0, "Opaque", "Render surface without transparency"},
685                 {MA_BM_ADD, "ADD", 0, "Additive", "Render surface and blend the result with additive blending"},
686                 {MA_BM_MULTIPLY, "MULTIPLY", 0, "Multiply", "Render surface and blend the result with multiplicative blending"},
687                 {MA_BM_CLIP, "CLIP", 0, "Alpha Clip", "Use the alpha threshold to clip the visibility (binary visibility)"},
688                 {MA_BM_HASHED, "HASHED", 0, "Alpha Hashed", "Use noise to dither the binary visibility (works well with multi-samples)"},
689                 {MA_BM_BLEND, "BLEND", 0, "Alpha Blend", "Render polygon transparent, depending on alpha channel of the texture"},
690                 {0, NULL, 0, NULL, NULL}
691         };
692
693         static EnumPropertyItem prop_eevee_blend_shadow_items[] = {
694                 {MA_BS_NONE, "NONE", 0, "None", "Material will cast no shadow"},
695                 {MA_BS_SOLID, "OPAQUE", 0, "Opaque", "Material will cast shadows without transparency"},
696                 {MA_BS_CLIP, "CLIP", 0, "Clip", "Use the alpha threshold to clip the visibility (binary visibility)"},
697                 {MA_BS_HASHED, "HASHED", 0, "Hashed", "Use noise to dither the binary visibility and use filtering to reduce the noise"},
698                 {0, NULL, 0, NULL, NULL}
699         };
700
701         srna = RNA_def_struct(brna, "Material", "ID");
702         RNA_def_struct_ui_text(srna, "Material",
703                                "Material data-block to define the appearance of geometric objects for rendering");
704         RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
705
706         /* Blending (only Eevee for now) */
707         prop = RNA_def_property(srna, "blend_method", PROP_ENUM, PROP_NONE);
708         RNA_def_property_enum_items(prop, prop_eevee_blend_items);
709         RNA_def_property_ui_text(prop, "Blend Mode", "Blend Mode for Transparent Faces");
710         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
711
712         prop = RNA_def_property(srna, "transparent_shadow_method", PROP_ENUM, PROP_NONE);
713         RNA_def_property_enum_sdna(prop, NULL, "blend_shadow");
714         RNA_def_property_enum_items(prop, prop_eevee_blend_shadow_items);
715         RNA_def_property_ui_text(prop, "Transparent Shadow", "Shadow method for transparent material");
716         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
717
718         prop = RNA_def_property(srna, "alpha_threshold", PROP_FLOAT, PROP_FACTOR);
719         RNA_def_property_range(prop, 0, 1);
720         RNA_def_property_ui_text(prop, "Clip Threshold", "A pixel is rendered only if its alpha value is above this threshold");
721         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
722
723         prop = RNA_def_property(srna, "show_transparent_backside", PROP_BOOLEAN, PROP_NONE);
724         RNA_def_property_boolean_negative_sdna(prop, NULL, "blend_flag", MA_BL_HIDE_BACKSIDE);
725         RNA_def_property_ui_text(prop, "Show Backside", "Limit transparency to a single layer "
726                                                          "(avoids transparency sorting problems)");
727         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
728
729         prop = RNA_def_property(srna, "use_screen_refraction", PROP_BOOLEAN, PROP_NONE);
730         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MA_BL_SS_REFRACTION);
731         RNA_def_property_ui_text(prop, "Screen Space Refraction", "Use raytraced screen space refractions");
732         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
733
734         prop = RNA_def_property(srna, "use_sss_translucency", PROP_BOOLEAN, PROP_NONE);
735         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MA_BL_TRANSLUCENCY);
736         RNA_def_property_ui_text(prop, "Subsurface Translucency", "Add translucency effect to subsurface");
737         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
738
739         prop = RNA_def_property(srna, "refraction_depth", PROP_FLOAT, PROP_DISTANCE);
740         RNA_def_property_float_sdna(prop, NULL, "refract_depth");
741         RNA_def_property_range(prop, 0.0f, FLT_MAX);
742         RNA_def_property_ui_text(prop, "Refraction Depth", "Approximate the thickness of the object to compute two refraction "
743                                                            "event (0 is disabled)");
744         RNA_def_property_update(prop, 0, "rna_Material_draw_update");
745
746         /* For Preview Render */
747         prop = RNA_def_property(srna, "preview_render_type", PROP_ENUM, PROP_NONE);
748         RNA_def_property_enum_sdna(prop, NULL, "pr_type");
749         RNA_def_property_enum_items(prop, preview_type_items);
750         RNA_def_property_ui_text(prop, "Preview render type", "Type of preview render");
751         RNA_def_property_update(prop, 0, "rna_Material_update_previews");
752
753         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
754         RNA_def_property_int_sdna(prop, NULL, "index");
755         RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Material Index\" render pass");
756         RNA_def_property_update(prop, NC_OBJECT, "rna_Material_update");
757
758         /* nodetree */
759         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
760         RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
761         RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based materials");
762
763         prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
764         RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1);
765         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
766         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
767         RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the material");
768         RNA_def_property_update(prop, 0, "rna_Material_use_nodes_update");
769
770         /* common */
771         rna_def_animdata_common(srna);
772         rna_def_texpaint_slots(brna, srna);
773
774         rna_def_material_display(srna);
775
776         /* grease pencil */
777         prop = RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
778         RNA_def_property_pointer_sdna(prop, NULL, "gp_style");
779         RNA_def_property_ui_text(prop, "Grease Pencil Settings", "Grease pencil color settings for material");
780
781         prop = RNA_def_property(srna, "is_grease_pencil", PROP_BOOLEAN, PROP_NONE);
782         RNA_def_property_boolean_funcs(prop, "rna_is_grease_pencil_get", NULL);
783         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
784         RNA_def_property_ui_text(prop, "Is Grease Pencil", "True if this material has grease pencil data");
785
786         rna_def_material_greasepencil(brna);
787
788
789         RNA_api_material(srna);
790 }
791
792
793 static void rna_def_texture_slots(BlenderRNA *brna, PropertyRNA *cprop, const char *structname,
794                                   const char *structname_slots)
795 {
796         StructRNA *srna;
797
798         FunctionRNA *func;
799         PropertyRNA *parm;
800
801         RNA_def_property_srna(cprop, structname_slots);
802         srna = RNA_def_struct(brna, structname_slots, NULL);
803         RNA_def_struct_sdna(srna, "ID");
804         RNA_def_struct_ui_text(srna, "Texture Slots", "Collection of texture slots");
805
806         /* functions */
807         func = RNA_def_function(srna, "add", "rna_mtex_texture_slots_add");
808         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
809         parm = RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex");
810         RNA_def_function_return(func, parm);
811
812         func = RNA_def_function(srna, "create", "rna_mtex_texture_slots_create");
813         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
814         parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to initialize", 0, INT_MAX);
815         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
816         parm = RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex");
817         RNA_def_function_return(func, parm);
818
819         func = RNA_def_function(srna, "clear", "rna_mtex_texture_slots_clear");
820         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_NO_SELF | FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
821         parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to clear", 0, INT_MAX);
822         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
823 }
824
825 void rna_def_mtex_common(BlenderRNA *brna, StructRNA *srna, const char *begin,
826                          const char *activeget, const char *activeset, const char *activeeditable,
827                          const char *structname, const char *structname_slots, const char *update, const char *update_index)
828 {
829         PropertyRNA *prop;
830
831         /* mtex */
832         prop = RNA_def_property(srna, "texture_slots", PROP_COLLECTION, PROP_NONE);
833         RNA_def_property_struct_type(prop, structname);
834         RNA_def_property_collection_funcs(prop, begin, "rna_iterator_array_next", "rna_iterator_array_end",
835                                           "rna_iterator_array_dereference_get", NULL, NULL, NULL, NULL);
836         RNA_def_property_ui_text(prop, "Textures", "Texture slots defining the mapping and influence of textures");
837         rna_def_texture_slots(brna, prop, structname, structname_slots);
838
839         prop = RNA_def_property(srna, "active_texture", PROP_POINTER, PROP_NONE);
840         RNA_def_property_struct_type(prop, "Texture");
841         RNA_def_property_flag(prop, PROP_EDITABLE);
842         if (activeeditable)
843                 RNA_def_property_editable_func(prop, activeeditable);
844         RNA_def_property_pointer_funcs(prop, activeget, activeset, NULL, NULL);
845         RNA_def_property_ui_text(prop, "Active Texture", "Active texture slot being displayed");
846         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, update);
847
848         prop = RNA_def_property(srna, "active_texture_index", PROP_INT, PROP_UNSIGNED);
849         RNA_def_property_int_sdna(prop, NULL, "texact");
850         RNA_def_property_range(prop, 0, MAX_MTEX - 1);
851         RNA_def_property_ui_text(prop, "Active Texture Index", "Index of active texture slot");
852         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, update_index);
853 }
854
855 static void rna_def_tex_slot(BlenderRNA *brna)
856 {
857         StructRNA *srna;
858         PropertyRNA *prop;
859
860         srna = RNA_def_struct(brna, "TexPaintSlot", NULL);
861         RNA_def_struct_ui_text(srna, "Texture Paint Slot",
862                                "Slot that contains information about texture painting");
863
864         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
865         RNA_def_property_string_maxlength(prop, 64); /* else it uses the pointer size! */
866         RNA_def_property_string_sdna(prop, NULL, "uvname");
867         RNA_def_property_string_funcs(prop, "rna_TexPaintSlot_uv_layer_get", "rna_TexPaintSlot_uv_layer_length",
868                                       "rna_TexPaintSlot_uv_layer_set");
869         RNA_def_property_ui_text(prop, "UV Map", "Name of UV map");
870         RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Material_update");
871
872         prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
873         RNA_def_property_boolean_sdna(prop, NULL, "valid", 1);
874         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
875         RNA_def_property_ui_text(prop, "Valid", "Slot has a valid image and UV map");
876 }
877
878
879 void rna_def_texpaint_slots(BlenderRNA *brna, StructRNA *srna)
880 {
881         PropertyRNA *prop;
882
883         rna_def_tex_slot(brna);
884
885         /* mtex */
886         prop = RNA_def_property(srna, "texture_paint_images", PROP_COLLECTION, PROP_NONE);
887         RNA_def_property_collection_sdna(prop, NULL, "texpaintslot", NULL);
888         RNA_def_property_collection_funcs(prop, "rna_Material_texpaint_begin", "rna_iterator_array_next", "rna_iterator_array_end",
889                                           "rna_iterator_array_dereference_get", NULL, NULL, NULL, NULL);
890         RNA_def_property_struct_type(prop, "Image");
891         RNA_def_property_ui_text(prop, "Texture Slot Images", "Texture images used for texture painting");
892
893         prop = RNA_def_property(srna, "texture_paint_slots", PROP_COLLECTION, PROP_NONE);
894         RNA_def_property_collection_funcs(prop, "rna_Material_texpaint_begin", "rna_iterator_array_next", "rna_iterator_array_end",
895                                           "rna_iterator_array_get", NULL, NULL, NULL, NULL);
896         RNA_def_property_struct_type(prop, "TexPaintSlot");
897         RNA_def_property_ui_text(prop, "Texture Slots", "Texture slots defining the mapping and influence of textures");
898
899         prop = RNA_def_property(srna, "paint_active_slot", PROP_INT, PROP_UNSIGNED);
900         RNA_def_property_range(prop, 0, SHRT_MAX);
901         RNA_def_property_ui_text(prop, "Active Paint Texture Index", "Index of active texture paint slot");
902         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, "rna_Material_active_paint_texture_index_update");
903
904         prop = RNA_def_property(srna, "paint_clone_slot", PROP_INT, PROP_UNSIGNED);
905         RNA_def_property_range(prop, 0, SHRT_MAX);
906         RNA_def_property_ui_text(prop, "Clone Paint Texture Index", "Index of clone texture paint slot");
907         RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, NULL);
908 }
909
910 #endif