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