Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_mesh.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).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /* note: the original vertex color stuff is now just used for
24  * getting info on the layers themselves, accessing the data is
25  * done through the (not yet written) mpoly interfaces.*/
26
27 /** \file blender/makesrna/intern/rna_mesh.c
28  *  \ingroup RNA
29  */
30
31 #include <stdlib.h>
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_material_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_object_types.h"
39
40 #include "BLI_math_base.h"
41 #include "BLI_math_rotation.h"
42 #include "BLI_utildefines.h"
43
44 #include "BKE_editmesh.h"
45
46 #include "RNA_access.h"
47 #include "RNA_define.h"
48 #include "RNA_types.h"
49 #include "RNA_enum_types.h"
50
51 #include "rna_internal.h"
52
53 #include "WM_types.h"
54
55 const EnumPropertyItem rna_enum_mesh_delimit_mode_items[] = {
56         {BMO_DELIM_NORMAL, "NORMAL", 0, "Normal", "Delimit by face directions"},
57         {BMO_DELIM_MATERIAL, "MATERIAL", 0, "Material", "Delimit by face material"},
58         {BMO_DELIM_SEAM, "SEAM", 0, "Seam", "Delimit by edge seams"},
59         {BMO_DELIM_SHARP, "SHARP", 0, "Sharp", "Delimit by sharp edges"},
60         {BMO_DELIM_UV, "UV", 0, "UVs", "Delimit by UV coordinates"},
61         {0, NULL, 0, NULL, NULL},
62 };
63
64 #ifdef RNA_RUNTIME
65
66 #include "DNA_scene_types.h"
67
68 #include "BLI_math.h"
69
70 #include "BKE_customdata.h"
71 #include "BKE_main.h"
72 #include "BKE_mesh.h"
73 #include "BKE_mesh_runtime.h"
74 #include "BKE_report.h"
75
76 #include "DEG_depsgraph.h"
77
78 #include "ED_mesh.h" /* XXX Bad level call */
79
80 #include "WM_api.h"
81
82 #include "rna_mesh_utils.h"
83
84
85 /* -------------------------------------------------------------------- */
86 /* Generic helpers */
87
88 static Mesh *rna_mesh(PointerRNA *ptr)
89 {
90         Mesh *me = (Mesh *)ptr->id.data;
91         return me;
92 }
93
94 static CustomData *rna_mesh_vdata_helper(Mesh *me)
95 {
96         return (me->edit_btmesh) ? &me->edit_btmesh->bm->vdata : &me->vdata;
97 }
98
99 static CustomData *rna_mesh_edata_helper(Mesh *me)
100 {
101         return (me->edit_btmesh) ? &me->edit_btmesh->bm->edata : &me->edata;
102 }
103
104 static CustomData *rna_mesh_pdata_helper(Mesh *me)
105 {
106         return (me->edit_btmesh) ? &me->edit_btmesh->bm->pdata : &me->pdata;
107 }
108
109 static CustomData *rna_mesh_ldata_helper(Mesh *me)
110 {
111         return (me->edit_btmesh) ? &me->edit_btmesh->bm->ldata : &me->ldata;
112 }
113
114 static CustomData *rna_mesh_fdata_helper(Mesh *me)
115 {
116         return (me->edit_btmesh) ? NULL : &me->fdata;
117 }
118
119 static CustomData *rna_mesh_vdata(PointerRNA *ptr)
120 {
121         Mesh *me = rna_mesh(ptr);
122         return rna_mesh_vdata_helper(me);
123 }
124 #if 0
125 static CustomData *rna_mesh_edata(PointerRNA *ptr)
126 {
127         Mesh *me = rna_mesh(ptr);
128         return rna_mesh_edata_helper(me);
129 }
130 #endif
131 static CustomData *rna_mesh_pdata(PointerRNA *ptr)
132 {
133         Mesh *me = rna_mesh(ptr);
134         return rna_mesh_pdata_helper(me);
135 }
136
137 static CustomData *rna_mesh_ldata(PointerRNA *ptr)
138 {
139         Mesh *me = rna_mesh(ptr);
140         return rna_mesh_ldata_helper(me);
141 }
142
143
144 /* -------------------------------------------------------------------- */
145 /* Generic CustomData Layer Functions */
146
147 static void rna_cd_layer_name_set(CustomData *cdata, CustomDataLayer *cdl, const char *value)
148 {
149         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
150         CustomData_set_layer_unique_name(cdata, cdl - cdata->layers);
151 }
152
153 /* avoid using where possible!, ideally the type is known */
154 static CustomData *rna_cd_from_layer(PointerRNA *ptr, CustomDataLayer *cdl)
155 {
156         /* find out where we come from by */
157         Mesh *me = ptr->id.data;
158         CustomData *cd;
159
160         /* rely on negative values wrapping */
161 #define TEST_CDL(cmd) if ((void)(cd = cmd(me)), ARRAY_HAS_ITEM(cdl, cd->layers, cd->totlayer)) return cd
162
163         TEST_CDL(rna_mesh_vdata_helper);
164         TEST_CDL(rna_mesh_edata_helper);
165         TEST_CDL(rna_mesh_pdata_helper);
166         TEST_CDL(rna_mesh_ldata_helper);
167         TEST_CDL(rna_mesh_fdata_helper);
168
169 #undef TEST_CDL
170
171         /* should _never_ happen */
172         return NULL;
173 }
174
175 static void rna_MeshVertexLayer_name_set(PointerRNA *ptr, const char *value)
176 {
177         rna_cd_layer_name_set(rna_mesh_vdata(ptr), (CustomDataLayer *)ptr->data, value);
178 }
179 #if 0
180 static void rna_MeshEdgeLayer_name_set(PointerRNA *ptr, const char *value)
181 {
182         rna_cd_layer_name_set(rna_mesh_edata(ptr), (CustomDataLayer *)ptr->data, value);
183 }
184 #endif
185 static void rna_MeshPolyLayer_name_set(PointerRNA *ptr, const char *value)
186 {
187         rna_cd_layer_name_set(rna_mesh_pdata(ptr), (CustomDataLayer *)ptr->data, value);
188 }
189 static void rna_MeshLoopLayer_name_set(PointerRNA *ptr, const char *value)
190 {
191         rna_cd_layer_name_set(rna_mesh_ldata(ptr), (CustomDataLayer *)ptr->data, value);
192 }
193 /* only for layers shared between types */
194 static void rna_MeshAnyLayer_name_set(PointerRNA *ptr, const char *value)
195 {
196         CustomData *cd = rna_cd_from_layer(ptr, (CustomDataLayer *)ptr->data);
197         rna_cd_layer_name_set(cd, (CustomDataLayer *)ptr->data, value);
198 }
199
200 static bool rna_Mesh_has_custom_normals_get(PointerRNA *ptr)
201 {
202         Mesh *me = ptr->data;
203         return BKE_mesh_has_custom_loop_normals(me);
204 }
205
206 /* -------------------------------------------------------------------- */
207 /* Update Callbacks */
208
209 static void rna_Mesh_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
210 {
211         ID *id = ptr->id.data;
212
213         /* cheating way for importers to avoid slow updates */
214         if (id->us > 0) {
215                 DEG_id_tag_update(id, 0);
216                 WM_main_add_notifier(NC_GEOM | ND_DATA, id);
217         }
218 }
219
220 static void rna_Mesh_update_data_edit_weight(Main *bmain, Scene *scene, PointerRNA *ptr)
221 {
222         BKE_mesh_batch_cache_dirty_tag(rna_mesh(ptr), BKE_MESH_BATCH_DIRTY_ALL);
223
224         rna_Mesh_update_data(bmain, scene, ptr);
225 }
226
227
228 static void rna_Mesh_update_data_edit_active_color(Main *bmain, Scene *scene, PointerRNA *ptr)
229 {
230         BKE_mesh_batch_cache_dirty_tag(rna_mesh(ptr), BKE_MESH_BATCH_DIRTY_ALL);
231
232         rna_Mesh_update_data(bmain, scene, ptr);
233 }
234 static void rna_Mesh_update_select(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
235 {
236         ID *id = ptr->id.data;
237         /* cheating way for importers to avoid slow updates */
238         if (id->us > 0) {
239                 WM_main_add_notifier(NC_GEOM | ND_SELECT, id);
240         }
241 }
242
243 void rna_Mesh_update_draw(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
244 {
245         ID *id = ptr->id.data;
246         /* cheating way for importers to avoid slow updates */
247         if (id->us > 0) {
248                 WM_main_add_notifier(NC_GEOM | ND_DATA, id);
249         }
250 }
251
252
253 static void rna_Mesh_update_vertmask(Main *bmain, Scene *scene, PointerRNA *ptr)
254 {
255         Mesh *me = ptr->data;
256         if ((me->editflag & ME_EDIT_PAINT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_FACE_SEL)) {
257                 me->editflag &= ~ME_EDIT_PAINT_FACE_SEL;
258         }
259
260         BKE_mesh_batch_cache_dirty_tag(me, BKE_MESH_BATCH_DIRTY_ALL);
261
262         rna_Mesh_update_draw(bmain, scene, ptr);
263 }
264
265 static void rna_Mesh_update_facemask(Main *bmain, Scene *scene, PointerRNA *ptr)
266 {
267         Mesh *me = ptr->data;
268         if ((me->editflag & ME_EDIT_PAINT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_FACE_SEL)) {
269                 me->editflag &= ~ME_EDIT_PAINT_VERT_SEL;
270         }
271
272         BKE_mesh_batch_cache_dirty_tag(me, BKE_MESH_BATCH_DIRTY_ALL);
273
274         rna_Mesh_update_draw(bmain, scene, ptr);
275 }
276
277
278 /* -------------------------------------------------------------------- */
279 /* Property get/set Callbacks  */
280
281 static void rna_MeshVertex_normal_get(PointerRNA *ptr, float *value)
282 {
283         MVert *mvert = (MVert *)ptr->data;
284         normal_short_to_float_v3(value, mvert->no);
285 }
286
287 static void rna_MeshVertex_normal_set(PointerRNA *ptr, const float *value)
288 {
289         MVert *mvert = (MVert *)ptr->data;
290         float no[3];
291
292         copy_v3_v3(no, value);
293         normalize_v3(no);
294         normal_float_to_short_v3(mvert->no, no);
295 }
296
297 static float rna_MeshVertex_bevel_weight_get(PointerRNA *ptr)
298 {
299         MVert *mvert = (MVert *)ptr->data;
300         return mvert->bweight / 255.0f;
301 }
302
303 static void rna_MeshVertex_bevel_weight_set(PointerRNA *ptr, float value)
304 {
305         MVert *mvert = (MVert *)ptr->data;
306         mvert->bweight = round_fl_to_uchar_clamp(value * 255.0f);
307 }
308
309 static float rna_MEdge_bevel_weight_get(PointerRNA *ptr)
310 {
311         MEdge *medge = (MEdge *)ptr->data;
312         return medge->bweight / 255.0f;
313 }
314
315 static void rna_MEdge_bevel_weight_set(PointerRNA *ptr, float value)
316 {
317         MEdge *medge = (MEdge *)ptr->data;
318         medge->bweight = round_fl_to_uchar_clamp(value * 255.0f);
319 }
320
321 static float rna_MEdge_crease_get(PointerRNA *ptr)
322 {
323         MEdge *medge = (MEdge *)ptr->data;
324         return medge->crease / 255.0f;
325 }
326
327 static void rna_MEdge_crease_set(PointerRNA *ptr, float value)
328 {
329         MEdge *medge = (MEdge *)ptr->data;
330         medge->crease = round_fl_to_uchar_clamp(value * 255.0f);
331 }
332
333 static void rna_MeshLoop_normal_get(PointerRNA *ptr, float *values)
334 {
335         Mesh *me = rna_mesh(ptr);
336         MLoop *ml = (MLoop *)ptr->data;
337         const float (*vec)[3] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_NORMAL);
338
339         if (!vec) {
340                 zero_v3(values);
341         }
342         else {
343                 copy_v3_v3(values, (const float *)vec);
344         }
345 }
346
347 static void rna_MeshLoop_normal_set(PointerRNA *ptr, const float *values)
348 {
349         Mesh *me = rna_mesh(ptr);
350         MLoop *ml = (MLoop *)ptr->data;
351         float (*vec)[3] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_NORMAL);
352
353         if (vec) {
354                 normalize_v3_v3(*vec, values);
355         }
356 }
357
358 static void rna_MeshLoop_tangent_get(PointerRNA *ptr, float *values)
359 {
360         Mesh *me = rna_mesh(ptr);
361         MLoop *ml = (MLoop *)ptr->data;
362         const float (*vec)[4] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_MLOOPTANGENT);
363
364         if (!vec) {
365                 zero_v3(values);
366         }
367         else {
368                 copy_v3_v3(values, (const float *)vec);
369         }
370 }
371
372 static float rna_MeshLoop_bitangent_sign_get(PointerRNA *ptr)
373 {
374         Mesh *me = rna_mesh(ptr);
375         MLoop *ml = (MLoop *)ptr->data;
376         const float (*vec)[4] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_MLOOPTANGENT);
377
378         return (vec) ? (*vec)[3] : 0.0f;
379 }
380
381 static void rna_MeshLoop_bitangent_get(PointerRNA *ptr, float *values)
382 {
383         Mesh *me = rna_mesh(ptr);
384         MLoop *ml = (MLoop *)ptr->data;
385         const float (*nor)[3] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_NORMAL);
386         const float (*vec)[4] = CustomData_get(&me->ldata, (int)(ml - me->mloop), CD_MLOOPTANGENT);
387
388         if (nor && vec) {
389                 cross_v3_v3v3(values, (const float *)nor, (const float *)vec);
390                 mul_v3_fl(values, (*vec)[3]);
391         }
392         else {
393                 zero_v3(values);
394         }
395 }
396
397 static void rna_MeshPolygon_normal_get(PointerRNA *ptr, float *values)
398 {
399         Mesh *me = rna_mesh(ptr);
400         MPoly *mp = (MPoly *)ptr->data;
401
402         BKE_mesh_calc_poly_normal(mp, me->mloop + mp->loopstart, me->mvert, values);
403 }
404
405 static void rna_MeshPolygon_center_get(PointerRNA *ptr, float *values)
406 {
407         Mesh *me = rna_mesh(ptr);
408         MPoly *mp = (MPoly *)ptr->data;
409
410         BKE_mesh_calc_poly_center(mp, me->mloop + mp->loopstart, me->mvert, values);
411 }
412
413 static float rna_MeshPolygon_area_get(PointerRNA *ptr)
414 {
415         Mesh *me = (Mesh *)ptr->id.data;
416         MPoly *mp = (MPoly *)ptr->data;
417
418         return BKE_mesh_calc_poly_area(mp, me->mloop + mp->loopstart, me->mvert);
419 }
420
421 static void rna_MeshPolygon_flip(ID *id, MPoly *mp)
422 {
423         Mesh *me = (Mesh *)id;
424
425         BKE_mesh_polygon_flip(mp, me->mloop, &me->ldata);
426         BKE_mesh_tessface_clear(me);
427         BKE_mesh_runtime_clear_geometry(me);
428 }
429
430 static void rna_MeshLoopTriangle_verts_get(PointerRNA *ptr, int *values)
431 {
432         Mesh *me = rna_mesh(ptr);
433         MLoopTri *lt = (MLoopTri *)ptr->data;
434         values[0] = me->mloop[lt->tri[0]].v;
435         values[1] = me->mloop[lt->tri[1]].v;
436         values[2] = me->mloop[lt->tri[2]].v;
437 }
438
439
440 static void rna_MeshLoopTriangle_normal_get(PointerRNA *ptr, float *values)
441 {
442         Mesh *me = rna_mesh(ptr);
443         MLoopTri *lt = (MLoopTri *)ptr->data;
444         unsigned int v1 = me->mloop[lt->tri[0]].v;
445         unsigned int v2 = me->mloop[lt->tri[1]].v;
446         unsigned int v3 = me->mloop[lt->tri[2]].v;
447
448         normal_tri_v3(values, me->mvert[v1].co, me->mvert[v2].co, me->mvert[v3].co);
449 }
450
451 static void rna_MeshLoopTriangle_split_normals_get(PointerRNA *ptr, float *values)
452 {
453         Mesh *me = rna_mesh(ptr);
454         const float (*lnors)[3] = CustomData_get_layer(&me->ldata, CD_NORMAL);
455
456         if (!lnors) {
457                 zero_v3(values + 0);
458                 zero_v3(values + 3);
459                 zero_v3(values + 6);
460         }
461         else {
462                 MLoopTri *lt = (MLoopTri *)ptr->data;
463                 copy_v3_v3(values + 0, lnors[lt->tri[0]]);
464                 copy_v3_v3(values + 3, lnors[lt->tri[1]]);
465                 copy_v3_v3(values + 6, lnors[lt->tri[2]]);
466         }
467 }
468
469 static float rna_MeshLoopTriangle_area_get(PointerRNA *ptr)
470 {
471         Mesh *me = rna_mesh(ptr);
472         MLoopTri *lt = (MLoopTri *)ptr->data;
473         unsigned int v1 = me->mloop[lt->tri[0]].v;
474         unsigned int v2 = me->mloop[lt->tri[1]].v;
475         unsigned int v3 = me->mloop[lt->tri[2]].v;
476
477         return area_tri_v3(me->mvert[v1].co, me->mvert[v2].co, me->mvert[v3].co);
478 }
479
480 static void rna_MeshLoopColor_color_get(PointerRNA *ptr, float *values)
481 {
482         MLoopCol *mlcol = (MLoopCol *)ptr->data;
483
484         values[0] = mlcol->r / 255.0f;
485         values[1] = mlcol->g / 255.0f;
486         values[2] = mlcol->b / 255.0f;
487         values[3] = mlcol->a / 255.0f;
488 }
489
490 static void rna_MeshLoopColor_color_set(PointerRNA *ptr, const float *values)
491 {
492         MLoopCol *mlcol = (MLoopCol *)ptr->data;
493
494         mlcol->r = round_fl_to_uchar_clamp(values[0] * 255.0f);
495         mlcol->g = round_fl_to_uchar_clamp(values[1] * 255.0f);
496         mlcol->b = round_fl_to_uchar_clamp(values[2] * 255.0f);
497         mlcol->a = round_fl_to_uchar_clamp(values[3] * 255.0f);
498 }
499
500 static int rna_Mesh_texspace_editable(PointerRNA *ptr, const char **UNUSED(r_info))
501 {
502         Mesh *me = (Mesh *)ptr->data;
503         return (me->texflag & ME_AUTOSPACE) ? 0 : PROP_EDITABLE;
504 }
505
506 static void rna_Mesh_texspace_size_get(PointerRNA *ptr, float values[3])
507 {
508         Mesh *me = (Mesh *)ptr->data;
509
510         if (me->bb == NULL || (me->bb->flag & BOUNDBOX_DIRTY)) {
511                 BKE_mesh_texspace_calc(me);
512         }
513
514         copy_v3_v3(values, me->size);
515 }
516
517 static void rna_Mesh_texspace_loc_get(PointerRNA *ptr, float values[3])
518 {
519         Mesh *me = (Mesh *)ptr->data;
520
521         if (me->bb == NULL || (me->bb->flag & BOUNDBOX_DIRTY)) {
522                 BKE_mesh_texspace_calc(me);
523         }
524
525         copy_v3_v3(values, me->loc);
526 }
527
528 static void rna_MeshVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
529 {
530         Mesh *me = rna_mesh(ptr);
531
532         if (me->dvert) {
533                 MVert *mvert = (MVert *)ptr->data;
534                 MDeformVert *dvert = me->dvert + (mvert - me->mvert);
535
536                 rna_iterator_array_begin(iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
537         }
538         else
539                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
540 }
541
542 static void rna_MeshVertex_undeformed_co_get(PointerRNA *ptr, float values[3])
543 {
544         Mesh *me = rna_mesh(ptr);
545         MVert *mvert = (MVert *)ptr->data;
546         float (*orco)[3] =  CustomData_get_layer(&me->vdata, CD_ORCO);
547
548         if (orco) {
549                 /* orco is normalized to 0..1, we do inverse to match mvert->co */
550                 float loc[3], size[3];
551
552                 BKE_mesh_texspace_get(me->texcomesh ? me->texcomesh : me, loc, NULL, size);
553                 madd_v3_v3v3v3(values, loc, orco[(mvert - me->mvert)], size);
554         }
555         else
556                 copy_v3_v3(values, mvert->co);
557 }
558
559 static int rna_CustomDataLayer_active_get(PointerRNA *ptr, CustomData *data, int type, bool render)
560 {
561         int n = ((CustomDataLayer *)ptr->data) - data->layers;
562
563         if (render) return (n == CustomData_get_render_layer_index(data, type));
564         else return (n == CustomData_get_active_layer_index(data, type));
565 }
566
567 static int rna_CustomDataLayer_clone_get(PointerRNA *ptr, CustomData *data, int type)
568 {
569         int n = ((CustomDataLayer *)ptr->data) - data->layers;
570
571         return (n == CustomData_get_clone_layer_index(data, type));
572 }
573
574 static void rna_CustomDataLayer_active_set(PointerRNA *ptr, CustomData *data, int value, int type, int render)
575 {
576         Mesh *me = ptr->id.data;
577         int n = (((CustomDataLayer *)ptr->data) - data->layers) - CustomData_get_layer_index(data, type);
578
579         if (value == 0)
580                 return;
581
582         if (render) CustomData_set_layer_render(data, type, n);
583         else CustomData_set_layer_active(data, type, n);
584
585         BKE_mesh_update_customdata_pointers(me, true);
586 }
587
588 static void rna_CustomDataLayer_clone_set(PointerRNA *ptr, CustomData *data, int value, int type)
589 {
590         int n = ((CustomDataLayer *)ptr->data) - data->layers;
591
592         if (value == 0)
593                 return;
594
595         CustomData_set_layer_clone_index(data, type, n);
596 }
597
598 static bool rna_MEdge_freestyle_edge_mark_get(PointerRNA *ptr)
599 {
600         Mesh *me = rna_mesh(ptr);
601         MEdge *medge = (MEdge *)ptr->data;
602         FreestyleEdge *fed = CustomData_get(&me->edata, (int)(medge - me->medge), CD_FREESTYLE_EDGE);
603
604         return fed && (fed->flag & FREESTYLE_EDGE_MARK) != 0;
605 }
606
607 static void rna_MEdge_freestyle_edge_mark_set(PointerRNA *ptr, bool value)
608 {
609         Mesh *me = rna_mesh(ptr);
610         MEdge *medge = (MEdge *)ptr->data;
611         FreestyleEdge *fed = CustomData_get(&me->edata, (int)(medge - me->medge), CD_FREESTYLE_EDGE);
612
613         if (!fed) {
614                 fed = CustomData_add_layer(&me->edata, CD_FREESTYLE_EDGE, CD_CALLOC, NULL, me->totedge);
615         }
616         if (value) {
617                 fed->flag |= FREESTYLE_EDGE_MARK;
618         }
619         else {
620                 fed->flag &= ~FREESTYLE_EDGE_MARK;
621         }
622 }
623
624 static bool rna_MPoly_freestyle_face_mark_get(PointerRNA *ptr)
625 {
626         Mesh *me = rna_mesh(ptr);
627         MPoly *mpoly = (MPoly *)ptr->data;
628         FreestyleFace *ffa = CustomData_get(&me->pdata, (int)(mpoly - me->mpoly), CD_FREESTYLE_FACE);
629
630         return ffa && (ffa->flag & FREESTYLE_FACE_MARK) != 0;
631 }
632
633 static void rna_MPoly_freestyle_face_mark_set(PointerRNA *ptr, int value)
634 {
635         Mesh *me = rna_mesh(ptr);
636         MPoly *mpoly = (MPoly *)ptr->data;
637         FreestyleFace *ffa = CustomData_get(&me->pdata, (int)(mpoly - me->mpoly), CD_FREESTYLE_FACE);
638
639         if (!ffa) {
640                 ffa = CustomData_add_layer(&me->pdata, CD_FREESTYLE_FACE, CD_CALLOC, NULL, me->totpoly);
641         }
642         if (value) {
643                 ffa->flag |= FREESTYLE_FACE_MARK;
644         }
645         else {
646                 ffa->flag &= ~FREESTYLE_FACE_MARK;
647         }
648 }
649
650 /* Generic UV rename! */
651 static void rna_MeshUVLayer_name_set(PointerRNA *ptr, const char *name)
652 {
653         char buf[MAX_CUSTOMDATA_LAYER_NAME];
654         BLI_strncpy_utf8(buf, name, MAX_CUSTOMDATA_LAYER_NAME);
655         BKE_mesh_uv_cdlayer_rename(rna_mesh(ptr), ((CustomDataLayer *)ptr->data)->name, buf, true);
656 }
657
658 /* uv_layers */
659
660 DEFINE_CUSTOMDATA_LAYER_COLLECTION(uv_layer, ldata, CD_MLOOPUV)
661 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, active, MeshUVLoopLayer)
662 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, clone, MeshUVLoopLayer)
663 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, stencil, MeshUVLoopLayer)
664 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, render, MeshUVLoopLayer)
665
666 /* MeshUVLoopLayer */
667
668 static char *rna_MeshUVLoopLayer_path(PointerRNA *ptr)
669 {
670         CustomDataLayer *cdl = ptr->data;
671         char name_esc[sizeof(cdl->name) * 2];
672         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
673         return BLI_sprintfN("uv_layers[\"%s\"]", name_esc);
674 }
675
676 static void rna_MeshUVLoopLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
677 {
678         Mesh *me = rna_mesh(ptr);
679         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
680         rna_iterator_array_begin(iter, layer->data, sizeof(MLoopUV), (me->edit_btmesh) ? 0 : me->totloop, 0, NULL);
681 }
682
683 static int rna_MeshUVLoopLayer_data_length(PointerRNA *ptr)
684 {
685         Mesh *me = rna_mesh(ptr);
686         return (me->edit_btmesh) ? 0 : me->totloop;
687 }
688
689 static bool rna_MeshUVLoopLayer_active_render_get(PointerRNA *ptr)
690 {
691         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPUV, 1);
692 }
693
694 static bool rna_MeshUVLoopLayer_active_get(PointerRNA *ptr)
695 {
696         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPUV, 0);
697 }
698
699 static bool rna_MeshUVLoopLayer_clone_get(PointerRNA *ptr)
700 {
701         return rna_CustomDataLayer_clone_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPUV);
702 }
703
704 static void rna_MeshUVLoopLayer_active_render_set(PointerRNA *ptr, bool value)
705 {
706         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPUV, 1);
707 }
708
709 static void rna_MeshUVLoopLayer_active_set(PointerRNA *ptr, bool value)
710 {
711         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPUV, 0);
712 }
713
714 static void rna_MeshUVLoopLayer_clone_set(PointerRNA *ptr, bool value)
715 {
716         rna_CustomDataLayer_clone_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPUV);
717 }
718
719 /* vertex_color_layers */
720
721 DEFINE_CUSTOMDATA_LAYER_COLLECTION(vertex_color, ldata, CD_MLOOPCOL)
722 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(vertex_color, ldata, CD_MLOOPCOL, active, MeshLoopColorLayer)
723 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(vertex_color, ldata, CD_MLOOPCOL, render, MeshLoopColorLayer)
724
725 static void rna_MeshLoopColorLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
726 {
727         Mesh *me = rna_mesh(ptr);
728         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
729         rna_iterator_array_begin(iter, layer->data, sizeof(MLoopCol), (me->edit_btmesh) ? 0 : me->totloop, 0, NULL);
730 }
731
732 static int rna_MeshLoopColorLayer_data_length(PointerRNA *ptr)
733 {
734         Mesh *me = rna_mesh(ptr);
735         return (me->edit_btmesh) ? 0 : me->totloop;
736 }
737
738 static bool rna_MeshLoopColorLayer_active_render_get(PointerRNA *ptr)
739 {
740         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPCOL, 1);
741 }
742
743 static bool rna_MeshLoopColorLayer_active_get(PointerRNA *ptr)
744 {
745         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPCOL, 0);
746 }
747
748 static void rna_MeshLoopColorLayer_active_render_set(PointerRNA *ptr, bool value)
749 {
750         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPCOL, 1);
751 }
752
753 static void rna_MeshLoopColorLayer_active_set(PointerRNA *ptr, bool value)
754 {
755         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPCOL, 0);
756 }
757
758 static int rna_float_layer_check(CollectionPropertyIterator *UNUSED(iter), void *data)
759 {
760         CustomDataLayer *layer = (CustomDataLayer *)data;
761         return (layer->type != CD_PROP_FLT);
762 }
763
764 static void rna_Mesh_vertex_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
765 {
766         CustomData *vdata = rna_mesh_vdata(ptr);
767         rna_iterator_array_begin(iter, (void *)vdata->layers, sizeof(CustomDataLayer), vdata->totlayer, 0,
768                                  rna_float_layer_check);
769 }
770 static void rna_Mesh_polygon_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
771 {
772         CustomData *pdata = rna_mesh_pdata(ptr);
773         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
774                                  rna_float_layer_check);
775 }
776
777 static int rna_Mesh_vertex_float_layers_length(PointerRNA *ptr)
778 {
779         return CustomData_number_of_layers(rna_mesh_vdata(ptr), CD_PROP_FLT);
780 }
781 static int rna_Mesh_polygon_float_layers_length(PointerRNA *ptr)
782 {
783         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_FLT);
784 }
785
786 static int rna_int_layer_check(CollectionPropertyIterator *UNUSED(iter), void *data)
787 {
788         CustomDataLayer *layer = (CustomDataLayer *)data;
789         return (layer->type != CD_PROP_INT);
790 }
791
792 static void rna_Mesh_vertex_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
793 {
794         CustomData *vdata = rna_mesh_vdata(ptr);
795         rna_iterator_array_begin(iter, (void *)vdata->layers, sizeof(CustomDataLayer), vdata->totlayer, 0,
796                                  rna_int_layer_check);
797 }
798 static void rna_Mesh_polygon_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
799 {
800         CustomData *pdata = rna_mesh_pdata(ptr);
801         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
802                                  rna_int_layer_check);
803 }
804
805 static int rna_Mesh_vertex_int_layers_length(PointerRNA *ptr)
806 {
807         return CustomData_number_of_layers(rna_mesh_vdata(ptr), CD_PROP_INT);
808 }
809 static int rna_Mesh_polygon_int_layers_length(PointerRNA *ptr)
810 {
811         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_INT);
812 }
813
814 static int rna_string_layer_check(CollectionPropertyIterator *UNUSED(iter), void *data)
815 {
816         CustomDataLayer *layer = (CustomDataLayer *)data;
817         return (layer->type != CD_PROP_STR);
818 }
819
820 static void rna_Mesh_vertex_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
821 {
822         CustomData *vdata = rna_mesh_vdata(ptr);
823         rna_iterator_array_begin(iter, (void *)vdata->layers, sizeof(CustomDataLayer), vdata->totlayer, 0,
824                                  rna_string_layer_check);
825 }
826 static void rna_Mesh_polygon_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
827 {
828         CustomData *pdata = rna_mesh_pdata(ptr);
829         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
830                                  rna_string_layer_check);
831 }
832
833 static int rna_Mesh_vertex_string_layers_length(PointerRNA *ptr)
834 {
835         return CustomData_number_of_layers(rna_mesh_vdata(ptr), CD_PROP_STR);
836 }
837 static int rna_Mesh_polygon_string_layers_length(PointerRNA *ptr)
838 {
839         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_STR);
840 }
841
842 /* Skin vertices */
843 DEFINE_CUSTOMDATA_LAYER_COLLECTION(skin_vertice, vdata, CD_MVERT_SKIN)
844
845 static char *rna_MeshSkinVertexLayer_path(PointerRNA *ptr)
846 {
847         CustomDataLayer *cdl = ptr->data;
848         char name_esc[sizeof(cdl->name) * 2];
849         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
850         return BLI_sprintfN("skin_vertices[\"%s\"]", name_esc);
851 }
852
853 static char *rna_VertCustomData_data_path(PointerRNA *ptr, const char *collection, int type);
854 static char *rna_MeshSkinVertex_path(PointerRNA *ptr)
855 {
856         return rna_VertCustomData_data_path(ptr, "skin_vertices", CD_MVERT_SKIN);
857 }
858
859 static void rna_MeshSkinVertexLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
860 {
861         Mesh *me = rna_mesh(ptr);
862         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
863         rna_iterator_array_begin(iter, layer->data, sizeof(MVertSkin), me->totvert, 0, NULL);
864 }
865
866 static int rna_MeshSkinVertexLayer_data_length(PointerRNA *ptr)
867 {
868         Mesh *me = rna_mesh(ptr);
869         return me->totvert;
870 }
871
872 /* End skin vertices */
873
874 /* Paint mask */
875 DEFINE_CUSTOMDATA_LAYER_COLLECTION(vertex_paint_mask, vdata, CD_PAINT_MASK)
876
877 static char *rna_MeshPaintMaskLayer_path(PointerRNA *ptr)
878 {
879         CustomDataLayer *cdl = ptr->data;
880         char name_esc[sizeof(cdl->name) * 2];
881         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
882         return BLI_sprintfN("vertex_paint_masks[\"%s\"]", name_esc);
883 }
884
885 static char *rna_MeshPaintMask_path(PointerRNA *ptr)
886 {
887         return rna_VertCustomData_data_path(ptr, "vertex_paint_masks", CD_PAINT_MASK);
888 }
889
890 static void rna_MeshPaintMaskLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
891 {
892         Mesh *me = rna_mesh(ptr);
893         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
894         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totvert, 0, NULL);
895 }
896
897 static int rna_MeshPaintMaskLayer_data_length(PointerRNA *ptr)
898 {
899         Mesh *me = rna_mesh(ptr);
900         return me->totvert;
901 }
902
903 /* End paint mask */
904
905 /* Face maps */
906
907 DEFINE_CUSTOMDATA_LAYER_COLLECTION(face_map, pdata, CD_FACEMAP)
908 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(face_map, pdata, CD_FACEMAP, active, MeshFaceMapLayer)
909
910 static char *rna_MeshFaceMapLayer_path(PointerRNA *ptr)
911 {
912         CustomDataLayer *cdl = ptr->data;
913         char name_esc[sizeof(cdl->name) * 2];
914         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
915         return BLI_sprintfN("face_maps[\"%s\"]", name_esc);
916 }
917
918 static void rna_MeshFaceMapLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
919 {
920         Mesh *me = rna_mesh(ptr);
921         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
922         rna_iterator_array_begin(iter, layer->data, sizeof(int), me->totpoly, 0, NULL);
923 }
924
925 static int rna_MeshFaceMapLayer_data_length(PointerRNA *ptr)
926 {
927         Mesh *me = rna_mesh(ptr);
928         return me->totpoly;
929 }
930
931 static PointerRNA rna_Mesh_face_map_new(struct Mesh *me, ReportList *reports, const char *name)
932 {
933         if (BKE_mesh_ensure_facemap_customdata(me) == false) {
934                 BKE_report(reports, RPT_ERROR, "Currently only single face-map layers are supported");
935                 return PointerRNA_NULL;
936         }
937
938         CustomData *pdata = rna_mesh_pdata_helper(me);
939
940         int index = CustomData_get_layer_index(pdata, CD_FACEMAP);
941         BLI_assert(index != -1);
942         CustomDataLayer *cdl = &pdata->layers[index];
943         rna_cd_layer_name_set(pdata, cdl, name);
944
945         PointerRNA ptr;
946         RNA_pointer_create(&me->id, &RNA_MeshFaceMapLayer, cdl, &ptr);
947         return ptr;
948 }
949
950 static void rna_Mesh_face_map_remove(struct Mesh *me, ReportList *reports, struct CustomDataLayer *layer)
951 {
952         /* just for sanity check */
953         {
954                 CustomData *pdata = rna_mesh_pdata_helper(me);
955                 int index = CustomData_get_layer_index(pdata, CD_FACEMAP);
956                 if (index != -1) {
957                         CustomDataLayer *layer_test = &pdata->layers[index];
958                         if (layer != layer_test) {
959                                 /* don't show name, its likely freed memory */
960                                 BKE_report(reports, RPT_ERROR, "FaceMap not in mesh");
961                                 return;
962                         }
963                 }
964         }
965
966         if (BKE_mesh_clear_facemap_customdata(me) == false) {
967                 BKE_reportf(reports, RPT_ERROR, "Error removing face-map");
968         }
969 }
970
971 /* End face maps */
972
973
974 /* poly.vertices - this is faked loop access for convenience */
975 static int rna_MeshPoly_vertices_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
976 {
977         MPoly *mp = (MPoly *)ptr->data;
978         /* note, raw access uses dummy item, this _could_ crash, watch out for this, mface uses it but it cant work here */
979         return (length[0] = mp->totloop);
980 }
981
982 static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
983 {
984         Mesh *me = rna_mesh(ptr);
985         MPoly *mp = (MPoly *)ptr->data;
986         MLoop *ml = &me->mloop[mp->loopstart];
987         unsigned int i;
988         for (i = mp->totloop; i > 0; i--, values++, ml++) {
989                 *values = ml->v;
990         }
991 }
992
993 static void rna_MeshPoly_vertices_set(PointerRNA *ptr, const int *values)
994 {
995         Mesh *me = rna_mesh(ptr);
996         MPoly *mp = (MPoly *)ptr->data;
997         MLoop *ml = &me->mloop[mp->loopstart];
998         unsigned int i;
999         for (i = mp->totloop; i > 0; i--, values++, ml++) {
1000                 ml->v = *values;
1001         }
1002 }
1003
1004 /* disabling, some importers don't know the total material count when assigning materials */
1005 #if 0
1006 static void rna_MeshPoly_material_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
1007 {
1008         Mesh *me = rna_mesh(ptr);
1009         *min = 0;
1010         *max = max_ii(0, me->totcol - 1);
1011 }
1012 #endif
1013
1014 static int rna_MeshVertex_index_get(PointerRNA *ptr)
1015 {
1016         Mesh *me = rna_mesh(ptr);
1017         MVert *vert = (MVert *)ptr->data;
1018         return (int)(vert - me->mvert);
1019 }
1020
1021 static int rna_MeshEdge_index_get(PointerRNA *ptr)
1022 {
1023         Mesh *me = rna_mesh(ptr);
1024         MEdge *edge = (MEdge *)ptr->data;
1025         return (int)(edge - me->medge);
1026 }
1027
1028 static int rna_MeshLoopTriangle_index_get(PointerRNA *ptr)
1029 {
1030         Mesh *me = rna_mesh(ptr);
1031         MLoopTri *ltri = (MLoopTri *)ptr->data;
1032         return (int)(ltri - me->runtime.looptris.array);
1033 }
1034
1035 static int rna_MeshLoopTriangle_material_index_get(PointerRNA *ptr)
1036 {
1037         Mesh *me = rna_mesh(ptr);
1038         MLoopTri *ltri = (MLoopTri *)ptr->data;
1039         return me->mpoly[ltri->poly].mat_nr;
1040 }
1041
1042 static bool rna_MeshLoopTriangle_use_smooth_get(PointerRNA *ptr)
1043 {
1044         Mesh *me = rna_mesh(ptr);
1045         MLoopTri *ltri = (MLoopTri *)ptr->data;
1046         return me->mpoly[ltri->poly].flag & ME_SMOOTH;
1047 }
1048
1049 static int rna_MeshPolygon_index_get(PointerRNA *ptr)
1050 {
1051         Mesh *me = rna_mesh(ptr);
1052         MPoly *mpoly = (MPoly *)ptr->data;
1053         return (int)(mpoly - me->mpoly);
1054 }
1055
1056 static int rna_MeshLoop_index_get(PointerRNA *ptr)
1057 {
1058         Mesh *me = rna_mesh(ptr);
1059         MLoop *mloop = (MLoop *)ptr->data;
1060         return (int)(mloop - me->mloop);
1061 }
1062
1063 /* path construction */
1064
1065 static char *rna_VertexGroupElement_path(PointerRNA *ptr)
1066 {
1067         Mesh *me = rna_mesh(ptr); /* XXX not always! */
1068         MDeformWeight *dw = (MDeformWeight *)ptr->data;
1069         MDeformVert *dvert;
1070         int a, b;
1071
1072         for (a = 0, dvert = me->dvert; a < me->totvert; a++, dvert++)
1073                 for (b = 0; b < dvert->totweight; b++)
1074                         if (dw == &dvert->dw[b])
1075                                 return BLI_sprintfN("vertices[%d].groups[%d]", a, b);
1076
1077         return NULL;
1078 }
1079
1080 static char *rna_MeshPolygon_path(PointerRNA *ptr)
1081 {
1082         return BLI_sprintfN("polygons[%d]", (int)((MPoly *)ptr->data - rna_mesh(ptr)->mpoly));
1083 }
1084
1085 static char *rna_MeshLoopTriangle_path(PointerRNA *ptr)
1086 {
1087         return BLI_sprintfN("loop_triangles[%d]", (int)((MLoopTri *)ptr->data - rna_mesh(ptr)->runtime.looptris.array));
1088 }
1089
1090 static char *rna_MeshEdge_path(PointerRNA *ptr)
1091 {
1092         return BLI_sprintfN("edges[%d]", (int)((MEdge *)ptr->data - rna_mesh(ptr)->medge));
1093 }
1094
1095 static char *rna_MeshLoop_path(PointerRNA *ptr)
1096 {
1097         return BLI_sprintfN("loops[%d]", (int)((MLoop *)ptr->data - rna_mesh(ptr)->mloop));
1098 }
1099
1100
1101 static char *rna_MeshVertex_path(PointerRNA *ptr)
1102 {
1103         return BLI_sprintfN("vertices[%d]", (int)((MVert *)ptr->data - rna_mesh(ptr)->mvert));
1104 }
1105
1106 static char *rna_VertCustomData_data_path(PointerRNA *ptr, const char *collection, int type)
1107 {
1108         CustomDataLayer *cdl;
1109         Mesh *me = rna_mesh(ptr);
1110         CustomData *vdata = rna_mesh_vdata(ptr);
1111         int a, b, totvert = (me->edit_btmesh) ? 0 : me->totvert;
1112
1113         for (cdl = vdata->layers, a = 0; a < vdata->totlayer; cdl++, a++) {
1114                 if (cdl->type == type) {
1115                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1116                         if (b >= 0 && b < totvert) {
1117                                 char name_esc[sizeof(cdl->name) * 2];
1118                                 BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1119                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, name_esc, b);
1120                         }
1121                 }
1122         }
1123
1124         return NULL;
1125 }
1126
1127 static char *rna_PolyCustomData_data_path(PointerRNA *ptr, const char *collection, int type)
1128 {
1129         CustomDataLayer *cdl;
1130         Mesh *me = rna_mesh(ptr);
1131         CustomData *pdata = rna_mesh_pdata(ptr);
1132         int a, b, totpoly = (me->edit_btmesh) ? 0 : me->totpoly;
1133
1134         for (cdl = pdata->layers, a = 0; a < pdata->totlayer; cdl++, a++) {
1135                 if (cdl->type == type) {
1136                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1137                         if (b >= 0 && b < totpoly) {
1138                                 char name_esc[sizeof(cdl->name) * 2];
1139                                 BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1140                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, name_esc, b);
1141                         }
1142                 }
1143         }
1144
1145         return NULL;
1146 }
1147
1148 static char *rna_LoopCustomData_data_path(PointerRNA *ptr, const char *collection, int type)
1149 {
1150         CustomDataLayer *cdl;
1151         Mesh *me = rna_mesh(ptr);
1152         CustomData *ldata = rna_mesh_ldata(ptr);
1153         int a, b, totloop = (me->edit_btmesh) ? 0 : me->totloop;
1154
1155         for (cdl = ldata->layers, a = 0; a < ldata->totlayer; cdl++, a++) {
1156                 if (cdl->type == type) {
1157                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1158                         if (b >= 0 && b < totloop) {
1159                                 char name_esc[sizeof(cdl->name) * 2];
1160                                 BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1161                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, name_esc, b);
1162                         }
1163                 }
1164         }
1165
1166         return NULL;
1167 }
1168
1169 static char *rna_MeshUVLoop_path(PointerRNA *ptr)
1170 {
1171         return rna_LoopCustomData_data_path(ptr, "uv_layers", CD_MLOOPUV);
1172 }
1173
1174 static char *rna_MeshLoopColorLayer_path(PointerRNA *ptr)
1175 {
1176         CustomDataLayer *cdl = ptr->data;
1177         char name_esc[sizeof(cdl->name) * 2];
1178         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1179         return BLI_sprintfN("vertex_colors[\"%s\"]", name_esc);
1180 }
1181
1182 static char *rna_MeshColor_path(PointerRNA *ptr)
1183 {
1184         return rna_LoopCustomData_data_path(ptr, "vertex_colors", CD_MLOOPCOL);
1185 }
1186
1187 /**** Float Property Layer API ****/
1188 static char *rna_MeshVertexFloatPropertyLayer_path(PointerRNA *ptr)
1189 {
1190         CustomDataLayer *cdl = ptr->data;
1191         char name_esc[sizeof(cdl->name) * 2];
1192         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1193         return BLI_sprintfN("vertex_float_layers[\"%s\"]", name_esc);
1194 }
1195 static char *rna_MeshPolygonFloatPropertyLayer_path(PointerRNA *ptr)
1196 {
1197         CustomDataLayer *cdl = ptr->data;
1198         char name_esc[sizeof(cdl->name) * 2];
1199         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1200         return BLI_sprintfN("polygon_float_layers[\"%s\"]", name_esc);
1201 }
1202
1203 static char *rna_MeshVertexFloatProperty_path(PointerRNA *ptr)
1204 {
1205         return rna_VertCustomData_data_path(ptr, "vertex_layers_float", CD_PROP_FLT);
1206 }
1207 static char *rna_MeshPolygonFloatProperty_path(PointerRNA *ptr)
1208 {
1209         return rna_PolyCustomData_data_path(ptr, "polygon_layers_float", CD_PROP_FLT);
1210 }
1211
1212 static void rna_MeshVertexFloatPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1213 {
1214         Mesh *me = rna_mesh(ptr);
1215         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1216         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totvert, 0, NULL);
1217 }
1218 static void rna_MeshPolygonFloatPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1219 {
1220         Mesh *me = rna_mesh(ptr);
1221         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1222         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totpoly, 0, NULL);
1223 }
1224
1225 static int rna_MeshVertexFloatPropertyLayer_data_length(PointerRNA *ptr)
1226 {
1227         Mesh *me = rna_mesh(ptr);
1228         return me->totvert;
1229 }
1230 static int rna_MeshPolygonFloatPropertyLayer_data_length(PointerRNA *ptr)
1231 {
1232         Mesh *me = rna_mesh(ptr);
1233         return me->totpoly;
1234 }
1235
1236 /**** Int Property Layer API ****/
1237 static char *rna_MeshVertexIntPropertyLayer_path(PointerRNA *ptr)
1238 {
1239         CustomDataLayer *cdl = ptr->data;
1240         char name_esc[sizeof(cdl->name) * 2];
1241         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1242         return BLI_sprintfN("vertex_int_layers[\"%s\"]", name_esc);
1243 }
1244 static char *rna_MeshPolygonIntPropertyLayer_path(PointerRNA *ptr)
1245 {
1246         CustomDataLayer *cdl = ptr->data;
1247         char name_esc[sizeof(cdl->name) * 2];
1248         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1249         return BLI_sprintfN("polygon_int_layers[\"%s\"]", name_esc);
1250 }
1251
1252 static char *rna_MeshVertexIntProperty_path(PointerRNA *ptr)
1253 {
1254         return rna_VertCustomData_data_path(ptr, "vertex_layers_int", CD_PROP_INT);
1255 }
1256 static char *rna_MeshPolygonIntProperty_path(PointerRNA *ptr)
1257 {
1258         return rna_PolyCustomData_data_path(ptr, "polygon_layers_int", CD_PROP_INT);
1259 }
1260
1261 static void rna_MeshVertexIntPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1262 {
1263         Mesh *me = rna_mesh(ptr);
1264         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1265         rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totvert, 0, NULL);
1266 }
1267 static void rna_MeshPolygonIntPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1268 {
1269         Mesh *me = rna_mesh(ptr);
1270         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1271         rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totpoly, 0, NULL);
1272 }
1273
1274 static int rna_MeshVertexIntPropertyLayer_data_length(PointerRNA *ptr)
1275 {
1276         Mesh *me = rna_mesh(ptr);
1277         return me->totvert;
1278 }
1279 static int rna_MeshPolygonIntPropertyLayer_data_length(PointerRNA *ptr)
1280 {
1281         Mesh *me = rna_mesh(ptr);
1282         return me->totpoly;
1283 }
1284
1285 /**** String Property Layer API ****/
1286 static char *rna_MeshVertexStringPropertyLayer_path(PointerRNA *ptr)
1287 {
1288         CustomDataLayer *cdl = ptr->data;
1289         char name_esc[sizeof(cdl->name) * 2];
1290         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1291         return BLI_sprintfN("vertex_string_layers[\"%s\"]", name_esc);
1292 }
1293 static char *rna_MeshPolygonStringPropertyLayer_path(PointerRNA *ptr)
1294 {
1295         CustomDataLayer *cdl = ptr->data;
1296         char name_esc[sizeof(cdl->name) * 2];
1297         BLI_strescape(name_esc, cdl->name, sizeof(name_esc));
1298         return BLI_sprintfN("polygon_string_layers[\"%s\"]", name_esc);
1299 }
1300
1301 static char *rna_MeshVertexStringProperty_path(PointerRNA *ptr)
1302 {
1303         return rna_VertCustomData_data_path(ptr, "vertex_layers_string", CD_PROP_STR);
1304 }
1305 static char *rna_MeshPolygonStringProperty_path(PointerRNA *ptr)
1306 {
1307         return rna_PolyCustomData_data_path(ptr, "polygon_layers_string", CD_PROP_STR);
1308 }
1309
1310 static void rna_MeshVertexStringPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1311 {
1312         Mesh *me = rna_mesh(ptr);
1313         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1314         rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totvert, 0, NULL);
1315 }
1316 static void rna_MeshPolygonStringPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1317 {
1318         Mesh *me = rna_mesh(ptr);
1319         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
1320         rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totpoly, 0, NULL);
1321 }
1322
1323 static int rna_MeshVertexStringPropertyLayer_data_length(PointerRNA *ptr)
1324 {
1325         Mesh *me = rna_mesh(ptr);
1326         return me->totvert;
1327 }
1328 static int rna_MeshPolygonStringPropertyLayer_data_length(PointerRNA *ptr)
1329 {
1330         Mesh *me = rna_mesh(ptr);
1331         return me->totpoly;
1332 }
1333
1334 /* XXX, we dont have proper byte string support yet, so for now use the (bytes + 1)
1335  * bmesh API exposes correct python/bytestring access */
1336 void rna_MeshStringProperty_s_get(PointerRNA *ptr, char *value)
1337 {
1338         MStringProperty *ms = (MStringProperty *)ptr->data;
1339         BLI_strncpy(value, ms->s, (int)ms->s_len + 1);
1340 }
1341
1342 int rna_MeshStringProperty_s_length(PointerRNA *ptr)
1343 {
1344         MStringProperty *ms = (MStringProperty *)ptr->data;
1345         return (int)ms->s_len + 1;
1346 }
1347
1348 void rna_MeshStringProperty_s_set(PointerRNA *ptr, const char *value)
1349 {
1350         MStringProperty *ms = (MStringProperty *)ptr->data;
1351         BLI_strncpy(ms->s, value, sizeof(ms->s));
1352 }
1353
1354 static char *rna_MeshFaceMap_path(PointerRNA *ptr)
1355 {
1356         return rna_PolyCustomData_data_path(ptr, "face_maps", CD_FACEMAP);
1357 }
1358
1359 /***************************************/
1360
1361 static int rna_Mesh_tot_vert_get(PointerRNA *ptr)
1362 {
1363         Mesh *me = rna_mesh(ptr);
1364         return me->edit_btmesh ? me->edit_btmesh->bm->totvertsel : 0;
1365 }
1366 static int rna_Mesh_tot_edge_get(PointerRNA *ptr)
1367 {
1368         Mesh *me = rna_mesh(ptr);
1369         return me->edit_btmesh ? me->edit_btmesh->bm->totedgesel : 0;
1370 }
1371 static int rna_Mesh_tot_face_get(PointerRNA *ptr)
1372 {
1373         Mesh *me = rna_mesh(ptr);
1374         return me->edit_btmesh ? me->edit_btmesh->bm->totfacesel : 0;
1375 }
1376
1377 static PointerRNA rna_Mesh_vertex_color_new(struct Mesh *me, const char *name)
1378 {
1379         PointerRNA ptr;
1380         CustomData *ldata;
1381         CustomDataLayer *cdl = NULL;
1382         int index = ED_mesh_color_add(me, name, false);
1383
1384         if (index != -1) {
1385                 ldata = rna_mesh_ldata_helper(me);
1386                 cdl = &ldata->layers[CustomData_get_layer_index_n(ldata, CD_MLOOPCOL, index)];
1387         }
1388
1389         RNA_pointer_create(&me->id, &RNA_MeshLoopColorLayer, cdl, &ptr);
1390         return ptr;
1391 }
1392
1393 static void rna_Mesh_vertex_color_remove(struct Mesh *me, ReportList *reports, CustomDataLayer *layer)
1394 {
1395         if (ED_mesh_color_remove_named(me, layer->name) == false) {
1396                 BKE_reportf(reports, RPT_ERROR, "Vertex color '%s' not found", layer->name);
1397         }
1398 }
1399
1400 #define DEFINE_CUSTOMDATA_PROPERTY_API(elemname, datatype, cd_prop_type, cdata, countvar, layertype) \
1401 static PointerRNA rna_Mesh_##elemname##_##datatype##_property_new(struct Mesh *me, const char *name) \
1402 { \
1403         PointerRNA ptr; \
1404         CustomDataLayer *cdl = NULL; \
1405         int index; \
1406  \
1407         CustomData_add_layer_named(&me->cdata, cd_prop_type, CD_DEFAULT, NULL, me->countvar, name); \
1408         index = CustomData_get_named_layer_index(&me->cdata, cd_prop_type, name); \
1409  \
1410         cdl = (index == -1) ? NULL : &(me->cdata.layers[index]); \
1411  \
1412         RNA_pointer_create(&me->id, &RNA_##layertype, cdl, &ptr); \
1413         return ptr; \
1414 }
1415
1416 DEFINE_CUSTOMDATA_PROPERTY_API(vertex, float, CD_PROP_FLT, vdata, totvert, MeshVertexFloatPropertyLayer)
1417 DEFINE_CUSTOMDATA_PROPERTY_API(vertex, int, CD_PROP_INT, vdata, totvert, MeshVertexIntPropertyLayer)
1418 DEFINE_CUSTOMDATA_PROPERTY_API(vertex, string, CD_PROP_STR, vdata, totvert, MeshVertexStringPropertyLayer)
1419 DEFINE_CUSTOMDATA_PROPERTY_API(polygon, float, CD_PROP_FLT, pdata, totpoly, MeshPolygonFloatPropertyLayer)
1420 DEFINE_CUSTOMDATA_PROPERTY_API(polygon, int, CD_PROP_INT, pdata, totpoly, MeshPolygonIntPropertyLayer)
1421 DEFINE_CUSTOMDATA_PROPERTY_API(polygon, string, CD_PROP_STR, pdata, totpoly, MeshPolygonStringPropertyLayer)
1422 #undef DEFINE_CUSTOMDATA_PROPERTY_API
1423
1424 static PointerRNA rna_Mesh_uv_layers_new(struct Mesh *me, const char *name)
1425 {
1426         PointerRNA ptr;
1427         CustomData *ldata;
1428         CustomDataLayer *cdl = NULL;
1429         int index = ED_mesh_uv_texture_add(me, name, false);
1430
1431         if (index != -1) {
1432                 ldata = rna_mesh_ldata_helper(me);
1433                 cdl = &ldata->layers[CustomData_get_layer_index_n(ldata, CD_MLOOPUV, index)];
1434         }
1435
1436         RNA_pointer_create(&me->id, &RNA_MeshUVLoopLayer, cdl, &ptr);
1437         return ptr;
1438 }
1439
1440 static void rna_Mesh_uv_layers_remove(struct Mesh *me, ReportList *reports, CustomDataLayer *layer)
1441 {
1442         if (ED_mesh_uv_texture_remove_named(me, layer->name) == false) {
1443                 BKE_reportf(reports, RPT_ERROR, "Texture layer '%s' not found", layer->name);
1444         }
1445 }
1446
1447 static bool rna_Mesh_is_editmode_get(PointerRNA *ptr)
1448 {
1449         Mesh *me = rna_mesh(ptr);
1450         return (me->edit_btmesh != NULL);
1451 }
1452
1453 /* only to quiet warnings */
1454 static void UNUSED_FUNCTION(rna_mesh_unused)(void)
1455 {
1456         /* unused functions made by macros */
1457         (void)rna_Mesh_skin_vertice_index_range;
1458         (void)rna_Mesh_vertex_paint_mask_index_range;
1459         (void)rna_Mesh_uv_layer_render_get;
1460         (void)rna_Mesh_uv_layer_render_index_get;
1461         (void)rna_Mesh_uv_layer_render_index_set;
1462         (void)rna_Mesh_uv_layer_render_set;
1463         (void)rna_Mesh_vertex_color_render_get;
1464         (void)rna_Mesh_vertex_color_render_index_get;
1465         (void)rna_Mesh_vertex_color_render_index_set;
1466         (void)rna_Mesh_vertex_color_render_set;
1467         (void)rna_Mesh_face_map_index_range;
1468         (void)rna_Mesh_face_map_active_index_set;
1469         (void)rna_Mesh_face_map_active_index_get;
1470         (void)rna_Mesh_face_map_active_set;
1471         /* end unused function block */
1472 }
1473
1474 #else
1475
1476 static void rna_def_mvert_group(BlenderRNA *brna)
1477 {
1478         StructRNA *srna;
1479         PropertyRNA *prop;
1480
1481         srna = RNA_def_struct(brna, "VertexGroupElement", NULL);
1482         RNA_def_struct_sdna(srna, "MDeformWeight");
1483         RNA_def_struct_path_func(srna, "rna_VertexGroupElement_path");
1484         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
1485         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
1486
1487         /* we can't point to actual group, it is in the object and so
1488          * there is no unique group to point to, hence the index */
1489         prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
1490         RNA_def_property_int_sdna(prop, NULL, "def_nr");
1491         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1492         RNA_def_property_ui_text(prop, "Group Index", "");
1493         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1494
1495         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
1496         RNA_def_property_range(prop, 0.0f, 1.0f);
1497         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
1498         RNA_def_property_update(prop, 0, "rna_Mesh_update_data_edit_weight");
1499 }
1500
1501 static void rna_def_mvert(BlenderRNA *brna)
1502 {
1503         StructRNA *srna;
1504         PropertyRNA *prop;
1505
1506         srna = RNA_def_struct(brna, "MeshVertex", NULL);
1507         RNA_def_struct_sdna(srna, "MVert");
1508         RNA_def_struct_ui_text(srna, "Mesh Vertex", "Vertex in a Mesh data-block");
1509         RNA_def_struct_path_func(srna, "rna_MeshVertex_path");
1510         RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
1511
1512         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1513         RNA_def_property_ui_text(prop, "Location", "");
1514         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1515
1516         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1517         /* RNA_def_property_float_sdna(prop, NULL, "no"); */
1518         RNA_def_property_array(prop, 3);
1519         RNA_def_property_range(prop, -1.0f, 1.0f);
1520         RNA_def_property_float_funcs(prop, "rna_MeshVertex_normal_get", "rna_MeshVertex_normal_set", NULL);
1521         RNA_def_property_ui_text(prop, "Normal", "Vertex Normal");
1522
1523         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1524         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1525         RNA_def_property_ui_text(prop, "Select", "");
1526         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1527
1528         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1529         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1530         RNA_def_property_ui_text(prop, "Hide", "");
1531         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1532
1533         prop = RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1534         RNA_def_property_float_funcs(prop, "rna_MeshVertex_bevel_weight_get", "rna_MeshVertex_bevel_weight_set", NULL);
1535         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier 'Only Vertices' option");
1536         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1537
1538         prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
1539         RNA_def_property_collection_funcs(prop, "rna_MeshVertex_groups_begin", "rna_iterator_array_next",
1540                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1541         RNA_def_property_struct_type(prop, "VertexGroupElement");
1542         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");
1543
1544         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1545         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1546         RNA_def_property_int_funcs(prop, "rna_MeshVertex_index_get", NULL, NULL);
1547         RNA_def_property_ui_text(prop, "Index", "Index of this vertex");
1548
1549         prop = RNA_def_property(srna, "undeformed_co", PROP_FLOAT, PROP_TRANSLATION);
1550         RNA_def_property_array(prop, 3);
1551         RNA_def_property_ui_text(prop, "Undeformed Location",
1552                                  "For meshes with modifiers applied, the coordinate of the vertex with no deforming "
1553                                  "modifiers applied, as used for generated texture coordinates");
1554         RNA_def_property_float_funcs(prop, "rna_MeshVertex_undeformed_co_get", NULL, NULL);
1555         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1556 }
1557
1558 static void rna_def_medge(BlenderRNA *brna)
1559 {
1560         StructRNA *srna;
1561         PropertyRNA *prop;
1562
1563         srna = RNA_def_struct(brna, "MeshEdge", NULL);
1564         RNA_def_struct_sdna(srna, "MEdge");
1565         RNA_def_struct_ui_text(srna, "Mesh Edge", "Edge in a Mesh data-block");
1566         RNA_def_struct_path_func(srna, "rna_MeshEdge_path");
1567         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1568
1569         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1570         RNA_def_property_int_sdna(prop, NULL, "v1");
1571         RNA_def_property_array(prop, 2);
1572         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1573         /* XXX allows creating invalid meshes */
1574
1575         prop = RNA_def_property(srna, "crease", PROP_FLOAT, PROP_NONE);
1576         RNA_def_property_float_funcs(prop, "rna_MEdge_crease_get", "rna_MEdge_crease_set", NULL);
1577         RNA_def_property_ui_text(prop, "Crease", "Weight used by the Subdivision Surface modifier for creasing");
1578         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1579
1580         prop = RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1581         RNA_def_property_float_funcs(prop, "rna_MEdge_bevel_weight_get", "rna_MEdge_bevel_weight_set", NULL);
1582         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier");
1583         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1584
1585         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1586         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1587         RNA_def_property_ui_text(prop, "Select", "");
1588         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1589
1590         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1591         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1592         RNA_def_property_ui_text(prop, "Hide", "");
1593         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1594
1595         prop = RNA_def_property(srna, "use_seam", PROP_BOOLEAN, PROP_NONE);
1596         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SEAM);
1597         RNA_def_property_ui_text(prop, "Seam", "Seam edge for UV unwrapping");
1598         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1599
1600         prop = RNA_def_property(srna, "use_edge_sharp", PROP_BOOLEAN, PROP_NONE);
1601         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SHARP);
1602         RNA_def_property_ui_text(prop, "Sharp", "Sharp edge for the Edge Split modifier");
1603         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1604
1605         prop = RNA_def_property(srna, "is_loose", PROP_BOOLEAN, PROP_NONE);
1606         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_LOOSEEDGE);
1607         RNA_def_property_ui_text(prop, "Loose", "Loose edge");
1608
1609         prop = RNA_def_property(srna, "use_freestyle_mark", PROP_BOOLEAN, PROP_NONE);
1610         RNA_def_property_boolean_funcs(prop, "rna_MEdge_freestyle_edge_mark_get", "rna_MEdge_freestyle_edge_mark_set");
1611         RNA_def_property_ui_text(prop, "Freestyle Edge Mark", "Edge mark for Freestyle line rendering");
1612         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1613
1614         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1615         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1616         RNA_def_property_int_funcs(prop, "rna_MeshEdge_index_get", NULL, NULL);
1617         RNA_def_property_ui_text(prop, "Index", "Index of this edge");
1618 }
1619
1620 static void rna_def_mlooptri(BlenderRNA *brna)
1621 {
1622         StructRNA *srna;
1623         PropertyRNA *prop;
1624         const int splitnor_dim[] = {3, 3};
1625
1626         srna = RNA_def_struct(brna, "MeshLoopTriangle", NULL);
1627         RNA_def_struct_sdna(srna, "MLoopTri");
1628         RNA_def_struct_ui_text(srna, "Mesh Loop Triangle", "Tessellated triangle in a Mesh data-block");
1629         RNA_def_struct_path_func(srna, "rna_MeshLoopTriangle_path");
1630         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1631
1632         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1633         RNA_def_property_array(prop, 3);
1634         RNA_def_property_int_funcs(prop, "rna_MeshLoopTriangle_verts_get", NULL, NULL);
1635         RNA_def_property_ui_text(prop, "Vertices", "Indices of triangle vertices");
1636         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1637
1638         prop = RNA_def_property(srna, "loops", PROP_INT, PROP_UNSIGNED);
1639         RNA_def_property_int_sdna(prop, NULL, "tri");
1640         RNA_def_property_ui_text(prop, "Loops", "Indices of mesh loops that make up the triangle");
1641         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1642
1643         prop = RNA_def_property(srna, "polygon_index", PROP_INT, PROP_UNSIGNED);
1644         RNA_def_property_int_sdna(prop, NULL, "poly");
1645         RNA_def_property_ui_text(prop, "Polygon", "Index of mesh polygon that the triangle is a part of");
1646         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1647
1648         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1649         RNA_def_property_array(prop, 3);
1650         RNA_def_property_range(prop, -1.0f, 1.0f);
1651         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1652         RNA_def_property_float_funcs(prop, "rna_MeshLoopTriangle_normal_get", NULL, NULL);
1653         RNA_def_property_ui_text(prop, "Triangle Normal", "Local space unit length normal vector for this triangle");
1654
1655         prop = RNA_def_property(srna, "split_normals", PROP_FLOAT, PROP_DIRECTION);
1656         RNA_def_property_multi_array(prop, 2, splitnor_dim);
1657         RNA_def_property_range(prop, -1.0f, 1.0f);
1658         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1659         RNA_def_property_float_funcs(prop, "rna_MeshLoopTriangle_split_normals_get", NULL, NULL);
1660         RNA_def_property_ui_text(prop, "Split Normals",
1661                                  "Local space unit length split normals vectors of the vertices of this triangle "
1662                                  "(must be computed beforehand using calc_normals_split or calc_tangents)");
1663
1664         prop = RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1665         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1666         RNA_def_property_float_funcs(prop, "rna_MeshLoopTriangle_area_get", NULL, NULL);
1667         RNA_def_property_ui_text(prop, "Triangle Area", "Area of this triangle");
1668
1669         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1670         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1671         RNA_def_property_int_funcs(prop, "rna_MeshLoopTriangle_index_get", NULL, NULL);
1672         RNA_def_property_ui_text(prop, "Index", "Index of this loop triangle");
1673
1674         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1675         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1676         RNA_def_property_int_funcs(prop, "rna_MeshLoopTriangle_material_index_get", NULL, NULL);
1677         RNA_def_property_ui_text(prop, "Material Index", "");
1678
1679         prop = RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1680         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1681         RNA_def_property_boolean_funcs(prop, "rna_MeshLoopTriangle_use_smooth_get", NULL);
1682         RNA_def_property_ui_text(prop, "Smooth", "");
1683 }
1684
1685 static void rna_def_mloop(BlenderRNA *brna)
1686 {
1687         StructRNA *srna;
1688         PropertyRNA *prop;
1689
1690         srna = RNA_def_struct(brna, "MeshLoop", NULL);
1691         RNA_def_struct_sdna(srna, "MLoop");
1692         RNA_def_struct_ui_text(srna, "Mesh Loop", "Loop in a Mesh data-block");
1693         RNA_def_struct_path_func(srna, "rna_MeshLoop_path");
1694         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1695
1696         prop = RNA_def_property(srna, "vertex_index", PROP_INT, PROP_UNSIGNED);
1697         RNA_def_property_int_sdna(prop, NULL, "v");
1698         RNA_def_property_ui_text(prop, "Vertex", "Vertex index");
1699
1700         prop = RNA_def_property(srna, "edge_index", PROP_INT, PROP_UNSIGNED);
1701         RNA_def_property_int_sdna(prop, NULL, "e");
1702         RNA_def_property_ui_text(prop, "Edge", "Edge index");
1703
1704         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1705         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1706         RNA_def_property_int_funcs(prop, "rna_MeshLoop_index_get", NULL, NULL);
1707         RNA_def_property_ui_text(prop, "Index", "Index of this loop");
1708
1709         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1710         RNA_def_property_array(prop, 3);
1711         RNA_def_property_range(prop, -1.0f, 1.0f);
1712         RNA_def_property_float_funcs(prop, "rna_MeshLoop_normal_get", "rna_MeshLoop_normal_set", NULL);
1713         RNA_def_property_ui_text(prop, "Normal",
1714                                  "Local space unit length split normal vector of this vertex for this polygon "
1715                                  "(must be computed beforehand using calc_normals_split or calc_tangents)");
1716
1717         prop = RNA_def_property(srna, "tangent", PROP_FLOAT, PROP_DIRECTION);
1718         RNA_def_property_array(prop, 3);
1719         RNA_def_property_range(prop, -1.0f, 1.0f);
1720         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1721         RNA_def_property_float_funcs(prop, "rna_MeshLoop_tangent_get", NULL, NULL);
1722         RNA_def_property_ui_text(prop, "Tangent",
1723                                  "Local space unit length tangent vector of this vertex for this polygon "
1724                                  "(must be computed beforehand using calc_tangents)");
1725
1726         prop = RNA_def_property(srna, "bitangent_sign", PROP_FLOAT, PROP_NONE);
1727         RNA_def_property_range(prop, -1.0f, 1.0f);
1728         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1729         RNA_def_property_float_funcs(prop, "rna_MeshLoop_bitangent_sign_get", NULL, NULL);
1730         RNA_def_property_ui_text(prop, "Bitangent Sign",
1731                                  "Sign of the bitangent vector of this vertex for this polygon (must be computed "
1732                                  "beforehand using calc_tangents, bitangent = bitangent_sign * cross(normal, tangent))");
1733
1734         prop = RNA_def_property(srna, "bitangent", PROP_FLOAT, PROP_DIRECTION);
1735         RNA_def_property_array(prop, 3);
1736         RNA_def_property_range(prop, -1.0f, 1.0f);
1737         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1738         RNA_def_property_float_funcs(prop, "rna_MeshLoop_bitangent_get", NULL, NULL);
1739         RNA_def_property_ui_text(prop, "Bitangent",
1740                                  "Bitangent vector of this vertex for this polygon (must be computed beforehand using "
1741                                  "calc_tangents, *use it only if really needed*, slower access than bitangent_sign)");
1742 }
1743
1744 static void rna_def_mpolygon(BlenderRNA *brna)
1745 {
1746         StructRNA *srna;
1747         PropertyRNA *prop;
1748         FunctionRNA *func;
1749
1750         srna = RNA_def_struct(brna, "MeshPolygon", NULL);
1751         RNA_def_struct_sdna(srna, "MPoly");
1752         RNA_def_struct_ui_text(srna, "Mesh Polygon", "Polygon in a Mesh data-block");
1753         RNA_def_struct_path_func(srna, "rna_MeshPolygon_path");
1754         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1755
1756         /* Faked, actually access to loop vertex values, don't this way because manually setting up
1757          * vertex/edge per loop is very low level.
1758          * Instead we setup poly sizes, assign indices, then calc edges automatic when creating
1759          * meshes from rna/py. */
1760         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1761         /* Eek, this is still used in some cases but in fact we don't want to use it at all here. */
1762         RNA_def_property_array(prop, 3);
1763         RNA_def_property_flag(prop, PROP_DYNAMIC);
1764         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshPoly_vertices_get_length");
1765         RNA_def_property_int_funcs(prop, "rna_MeshPoly_vertices_get", "rna_MeshPoly_vertices_set", NULL);
1766         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1767
1768         /* these are both very low level access */
1769         prop = RNA_def_property(srna, "loop_start", PROP_INT, PROP_UNSIGNED);
1770         RNA_def_property_int_sdna(prop, NULL, "loopstart");
1771         RNA_def_property_ui_text(prop, "Loop Start", "Index of the first loop of this polygon");
1772         /* also low level */
1773         prop = RNA_def_property(srna, "loop_total", PROP_INT, PROP_UNSIGNED);
1774         RNA_def_property_int_sdna(prop, NULL, "totloop");
1775         RNA_def_property_ui_text(prop, "Loop Total", "Number of loops used by this polygon");
1776
1777         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1778         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1779         RNA_def_property_ui_text(prop, "Material Index", "");
1780 #if 0
1781         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshPoly_material_index_range");
1782 #endif
1783         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1784
1785         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1786         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1787         RNA_def_property_ui_text(prop, "Select", "");
1788         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1789
1790         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1791         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1792         RNA_def_property_ui_text(prop, "Hide", "");
1793         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1794
1795         prop = RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1796         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1797         RNA_def_property_ui_text(prop, "Smooth", "");
1798         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1799
1800         prop = RNA_def_property(srna, "use_freestyle_mark", PROP_BOOLEAN, PROP_NONE);
1801         RNA_def_property_boolean_funcs(prop, "rna_MPoly_freestyle_face_mark_get", "rna_MPoly_freestyle_face_mark_set");
1802         RNA_def_property_ui_text(prop, "Freestyle Face Mark", "Face mark for Freestyle line rendering");
1803         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1804
1805         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1806         RNA_def_property_array(prop, 3);
1807         RNA_def_property_range(prop, -1.0f, 1.0f);
1808         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1809         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_normal_get", NULL, NULL);
1810         RNA_def_property_ui_text(prop, "Polygon Normal", "Local space unit length normal vector for this polygon");
1811
1812         prop = RNA_def_property(srna, "center", PROP_FLOAT, PROP_XYZ);
1813         RNA_def_property_array(prop, 3);
1814         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1815         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_center_get", NULL, NULL);
1816         RNA_def_property_ui_text(prop, "Polygon Center", "Center of this polygon");
1817
1818         prop = RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1819         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1820         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_area_get", NULL, NULL);
1821         RNA_def_property_ui_text(prop, "Polygon Area", "Read only area of this polygon");
1822
1823         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1824         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1825         RNA_def_property_int_funcs(prop, "rna_MeshPolygon_index_get", NULL, NULL);
1826         RNA_def_property_ui_text(prop, "Index", "Index of this polygon");
1827
1828         func = RNA_def_function(srna, "flip", "rna_MeshPolygon_flip");
1829         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
1830         RNA_def_function_ui_description(func, "Invert winding of this polygon (flip its normal)");
1831 }
1832
1833 /* mesh.loop_uvs */
1834 static void rna_def_mloopuv(BlenderRNA *brna)
1835 {
1836         StructRNA *srna;
1837         PropertyRNA *prop;
1838
1839         srna = RNA_def_struct(brna, "MeshUVLoopLayer", NULL);
1840         RNA_def_struct_sdna(srna, "CustomDataLayer");
1841         RNA_def_struct_path_func(srna, "rna_MeshUVLoopLayer_path");
1842
1843         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1844         RNA_def_property_struct_type(prop, "MeshUVLoop");
1845         RNA_def_property_collection_funcs(prop, "rna_MeshUVLoopLayer_data_begin", "rna_iterator_array_next",
1846                                           "rna_iterator_array_end", "rna_iterator_array_get",
1847                                           "rna_MeshUVLoopLayer_data_length", NULL, NULL, NULL);
1848
1849         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1850         RNA_def_struct_name_property(srna, prop);
1851         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshUVLayer_name_set");
1852         RNA_def_property_ui_text(prop, "Name", "Name of UV map");
1853         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1854
1855         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1856         RNA_def_property_boolean_funcs(prop, "rna_MeshUVLoopLayer_active_get", "rna_MeshUVLoopLayer_active_set");
1857         RNA_def_property_ui_text(prop, "Active", "Set the map as active for display and editing");
1858         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1859
1860         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1861         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1862         RNA_def_property_boolean_funcs(prop, "rna_MeshUVLoopLayer_active_render_get",
1863                                        "rna_MeshUVLoopLayer_active_render_set");
1864         RNA_def_property_ui_text(prop, "Active Render", "Set the map as active for rendering");
1865         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1866
1867         prop = RNA_def_property(srna, "active_clone", PROP_BOOLEAN, PROP_NONE);
1868         RNA_def_property_boolean_sdna(prop, NULL, "active_clone", 0);
1869         RNA_def_property_boolean_funcs(prop, "rna_MeshUVLoopLayer_clone_get", "rna_MeshUVLoopLayer_clone_set");
1870         RNA_def_property_ui_text(prop, "Active Clone", "Set the map as active for cloning");
1871         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1872
1873         srna = RNA_def_struct(brna, "MeshUVLoop", NULL);
1874         RNA_def_struct_sdna(srna, "MLoopUV");
1875         RNA_def_struct_path_func(srna, "rna_MeshUVLoop_path");
1876
1877         prop = RNA_def_property(srna, "uv", PROP_FLOAT, PROP_XYZ);
1878         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1879
1880         prop = RNA_def_property(srna, "pin_uv", PROP_BOOLEAN, PROP_NONE);
1881         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_PINNED);
1882         RNA_def_property_ui_text(prop, "UV Pinned", "");
1883
1884         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1885         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_VERTSEL);
1886         RNA_def_property_ui_text(prop, "UV Select", "");
1887
1888         prop = RNA_def_property(srna, "select_edge", PROP_BOOLEAN, PROP_NONE);
1889         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_EDGESEL);
1890         RNA_def_property_ui_text(prop, "UV Edge Select", "");
1891 }
1892
1893 static void rna_def_mloopcol(BlenderRNA *brna)
1894 {
1895         StructRNA *srna;
1896         PropertyRNA *prop;
1897
1898         srna = RNA_def_struct(brna, "MeshLoopColorLayer", NULL);
1899         RNA_def_struct_ui_text(srna, "Mesh Vertex Color Layer", "Layer of vertex colors in a Mesh data-block");
1900         RNA_def_struct_sdna(srna, "CustomDataLayer");
1901         RNA_def_struct_path_func(srna, "rna_MeshLoopColorLayer_path");
1902         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
1903
1904         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1905         RNA_def_struct_name_property(srna, prop);
1906         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshLoopLayer_name_set");
1907         RNA_def_property_ui_text(prop, "Name", "Name of Vertex color layer");
1908         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1909
1910         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1911         RNA_def_property_boolean_funcs(prop, "rna_MeshLoopColorLayer_active_get", "rna_MeshLoopColorLayer_active_set");
1912         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1913         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1914
1915         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1916         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1917         RNA_def_property_boolean_funcs(prop, "rna_MeshLoopColorLayer_active_render_get",
1918                                        "rna_MeshLoopColorLayer_active_render_set");
1919         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1920         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1921
1922         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1923         RNA_def_property_struct_type(prop, "MeshLoopColor");
1924         RNA_def_property_ui_text(prop, "Data", "");
1925         RNA_def_property_collection_funcs(prop, "rna_MeshLoopColorLayer_data_begin", "rna_iterator_array_next",
1926                                           "rna_iterator_array_end", "rna_iterator_array_get",
1927                                           "rna_MeshLoopColorLayer_data_length", NULL, NULL, NULL);
1928
1929
1930         srna = RNA_def_struct(brna, "MeshLoopColor", NULL);
1931         RNA_def_struct_sdna(srna, "MLoopCol");
1932         RNA_def_struct_ui_text(srna, "Mesh Vertex Color", "Vertex loop colors in a Mesh");
1933         RNA_def_struct_path_func(srna, "rna_MeshColor_path");
1934
1935         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1936         RNA_def_property_array(prop, 4);
1937         RNA_def_property_range(prop, 0.0f, 1.0f);
1938         RNA_def_property_float_funcs(prop, "rna_MeshLoopColor_color_get", "rna_MeshLoopColor_color_set", NULL);
1939         RNA_def_property_ui_text(prop, "Color", "");
1940         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1941 }
1942
1943 static void rna_def_mproperties(BlenderRNA *brna)
1944 {
1945         StructRNA *srna;
1946         PropertyRNA *prop;
1947
1948         /* Float */
1949 #define MESH_FLOAT_PROPERTY_LAYER(elemname) \
1950         srna = RNA_def_struct(brna, "Mesh" elemname "FloatPropertyLayer", NULL); \
1951         RNA_def_struct_sdna(srna, "CustomDataLayer"); \
1952         RNA_def_struct_ui_text(srna, "Mesh " elemname " Float Property Layer", "User defined layer of floating point number values"); \
1953         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "FloatPropertyLayer_path"); \
1954  \
1955         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); \
1956         RNA_def_struct_name_property(srna, prop); \
1957         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshAnyLayer_name_set"); \
1958         RNA_def_property_ui_text(prop, "Name", ""); \
1959         RNA_def_property_update(prop, 0, "rna_Mesh_update_data"); \
1960  \
1961         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE); \
1962         RNA_def_property_struct_type(prop, "Mesh" elemname "FloatProperty"); \
1963         RNA_def_property_ui_text(prop, "Data", ""); \
1964         RNA_def_property_collection_funcs(prop, "rna_Mesh" elemname "FloatPropertyLayer_data_begin", "rna_iterator_array_next", \
1965                                           "rna_iterator_array_end", "rna_iterator_array_get", \
1966                                           "rna_Mesh" elemname "FloatPropertyLayer_data_length", NULL, NULL, NULL); \
1967  \
1968         srna = RNA_def_struct(brna, "Mesh" elemname "FloatProperty", NULL); \
1969         RNA_def_struct_sdna(srna, "MFloatProperty"); \
1970         RNA_def_struct_ui_text(srna, "Mesh " elemname " Float Property", \
1971                                "User defined floating point number value in a float properties layer"); \
1972         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "FloatProperty_path"); \
1973  \
1974         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE); \
1975         RNA_def_property_float_sdna(prop, NULL, "f"); \
1976         RNA_def_property_ui_text(prop, "Value", ""); \
1977         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1978
1979         /* Int */
1980 #define MESH_INT_PROPERTY_LAYER(elemname) \
1981         srna = RNA_def_struct(brna, "Mesh" elemname "IntPropertyLayer", NULL); \
1982         RNA_def_struct_sdna(srna, "CustomDataLayer"); \
1983         RNA_def_struct_ui_text(srna, "Mesh " elemname " Int Property Layer", "User defined layer of integer number values"); \
1984         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "IntPropertyLayer_path"); \
1985  \
1986         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); \
1987         RNA_def_struct_name_property(srna, prop); \
1988         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshAnyLayer_name_set"); \
1989         RNA_def_property_ui_text(prop, "Name", ""); \
1990         RNA_def_property_update(prop, 0, "rna_Mesh_update_data"); \
1991  \
1992         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE); \
1993         RNA_def_property_struct_type(prop, "Mesh" elemname "IntProperty"); \
1994         RNA_def_property_ui_text(prop, "Data", ""); \
1995         RNA_def_property_collection_funcs(prop, "rna_Mesh" elemname "IntPropertyLayer_data_begin", "rna_iterator_array_next", \
1996                                           "rna_iterator_array_end", "rna_iterator_array_get", \
1997                                           "rna_Mesh" elemname "IntPropertyLayer_data_length", NULL, NULL, NULL); \
1998  \
1999         srna = RNA_def_struct(brna, "Mesh" elemname "IntProperty", NULL); \
2000         RNA_def_struct_sdna(srna, "MIntProperty"); \
2001         RNA_def_struct_ui_text(srna, "Mesh " elemname " Int Property", \
2002                                "User defined integer number value in an integer properties layer"); \
2003         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "IntProperty_path"); \
2004  \
2005         prop = RNA_def_property(srna, "value", PROP_INT, PROP_NONE); \
2006         RNA_def_property_int_sdna(prop, NULL, "i"); \
2007         RNA_def_property_ui_text(prop, "Value", ""); \
2008         RNA_def_property_update(prop, 0, "rna_Mesh_update_data"); \
2009
2010         /* String */
2011 #define MESH_STRING_PROPERTY_LAYER(elemname) \
2012         srna = RNA_def_struct(brna, "Mesh" elemname "StringPropertyLayer", NULL); \
2013         RNA_def_struct_sdna(srna, "CustomDataLayer"); \
2014         RNA_def_struct_ui_text(srna, "Mesh " elemname " String Property Layer", "User defined layer of string text values"); \
2015         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "StringPropertyLayer_path"); \
2016  \
2017         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); \
2018         RNA_def_struct_name_property(srna, prop); \
2019         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshAnyLayer_name_set"); \
2020         RNA_def_property_ui_text(prop, "Name", ""); \
2021         RNA_def_property_update(prop, 0, "rna_Mesh_update_data"); \
2022  \
2023         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE); \
2024         RNA_def_property_struct_type(prop, "Mesh" elemname "StringProperty"); \
2025         RNA_def_property_ui_text(prop, "Data", ""); \
2026         RNA_def_property_collection_funcs(prop, "rna_Mesh" elemname "StringPropertyLayer_data_begin", "rna_iterator_array_next", \
2027                                           "rna_iterator_array_end", "rna_iterator_array_get", \
2028                                           "rna_Mesh" elemname "StringPropertyLayer_data_length", NULL, NULL, NULL); \
2029  \
2030         srna = RNA_def_struct(brna, "Mesh" elemname "StringProperty", NULL); \
2031         RNA_def_struct_sdna(srna, "MStringProperty"); \
2032         RNA_def_struct_ui_text(srna, "Mesh " elemname " String Property", \
2033                                "User defined string text value in a string properties layer"); \
2034         RNA_def_struct_path_func(srna, "rna_Mesh" elemname "StringProperty_path"); \
2035  \
2036         /* low level mesh data access, treat as bytes */ \
2037         prop = RNA_def_property(srna, "value", PROP_STRING, PROP_BYTESTRING); \
2038         RNA_def_property_string_sdna(prop, NULL, "s"); \
2039         RNA_def_property_string_funcs(prop, "rna_MeshStringProperty_s_get", "rna_MeshStringProperty_s_length", "rna_MeshStringProperty_s_set"); \
2040         RNA_def_property_ui_text(prop, "Value", ""); \
2041         RNA_def_property_update(prop, 0, "rna_Mesh_update_data"); \
2042
2043         MESH_FLOAT_PROPERTY_LAYER("Vertex")
2044         MESH_FLOAT_PROPERTY_LAYER("Polygon")
2045         MESH_INT_PROPERTY_LAYER("Vertex")
2046         MESH_INT_PROPERTY_LAYER("Polygon")
2047         MESH_STRING_PROPERTY_LAYER("Vertex")
2048         MESH_STRING_PROPERTY_LAYER("Polygon")
2049 #undef MESH_PROPERTY_LAYER
2050
2051 }
2052
2053 void rna_def_texmat_common(StructRNA *srna, const char *texspace_editable)
2054 {
2055         PropertyRNA *prop;
2056
2057         /* texture space */
2058         prop = RNA_def_property(srna, "auto_texspace", PROP_BOOLEAN, PROP_NONE);
2059         RNA_def_property_boolean_sdna(prop, NULL, "texflag", ME_AUTOSPACE);
2060         RNA_def_property_ui_text(prop, "Auto Texture Space",
2061                                  "Adjust active object's texture space automatically when transforming object");
2062
2063         prop = RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
2064         RNA_def_property_float_sdna(prop, NULL, "loc");
2065         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
2066         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_loc_get", NULL, NULL);
2067         RNA_def_property_editable_func(prop, texspace_editable);
2068         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2069
2070         prop = RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
2071         RNA_def_property_float_sdna(prop, NULL, "size");
2072         RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2073         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size");
2074         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_size_get", NULL, NULL);
2075         RNA_def_property_editable_func(prop, texspace_editable);
2076         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2077
2078         /* not supported yet */
2079 #if 0
2080         prop = RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
2081         RNA_def_property_float(prop, NULL, "rot");
2082         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
2083         RNA_def_property_editable_func(prop, texspace_editable);
2084         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2085 #endif
2086
2087         /* materials */
2088         prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
2089         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
2090         RNA_def_property_struct_type(prop, "Material");
2091         RNA_def_property_ui_text(prop, "Materials", "");
2092         RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
2093         RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
2094 }
2095
2096
2097 /* scene.objects */
2098 /* mesh.vertices */
2099 static void rna_def_mesh_vertices(BlenderRNA *brna, PropertyRNA *cprop)
2100 {
2101         StructRNA *srna;
2102 /*      PropertyRNA *prop; */
2103
2104         FunctionRNA *func;
2105         PropertyRNA *parm;
2106
2107         RNA_def_property_srna(cprop, "MeshVertices");
2108         srna = RNA_def_struct(brna, "MeshVertices", NULL);
2109         RNA_def_struct_sdna(srna, "Mesh");
2110         RNA_def_struct_ui_text(srna, "Mesh Vertices", "Collection of mesh vertices");
2111
2112         func = RNA_def_function(srna, "add", "ED_mesh_vertices_add");
2113         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2114         parm = RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to add", 0, INT_MAX);
2115         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2116 #if 0 /* BMESH_TODO Remove until BMesh merge */
2117         func = RNA_def_function(srna, "remove", "ED_mesh_vertices_remove");
2118         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2119         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to remove", 0, INT_MAX);
2120 #endif
2121 }
2122
2123 /* mesh.edges */
2124 static void rna_def_mesh_edges(BlenderRNA *brna, PropertyRNA *cprop)
2125 {
2126         StructRNA *srna;
2127 /*      PropertyRNA *prop; */
2128
2129         FunctionRNA *func;
2130         PropertyRNA *parm;
2131
2132         RNA_def_property_srna(cprop, "MeshEdges");
2133         srna = RNA_def_struct(brna, "MeshEdges", NULL);
2134         RNA_def_struct_sdna(srna, "Mesh");
2135         RNA_def_struct_ui_text(srna, "Mesh Edges", "Collection of mesh edges");
2136
2137         func = RNA_def_function(srna, "add", "ED_mesh_edges_add");
2138         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2139         parm = RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of edges to add", 0, INT_MAX);
2140         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2141 #if 0 /* BMESH_TODO Remove until BMesh merge */
2142         func = RNA_def_function(srna, "remove", "ED_mesh_edges_remove");
2143         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2144         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of edges to remove", 0, INT_MAX);
2145 #endif
2146 }
2147
2148 /* mesh.loop_triangles */
2149 static void rna_def_mesh_looptris(BlenderRNA *brna, PropertyRNA *cprop)
2150 {
2151         StructRNA *srna;
2152
2153         RNA_def_property_srna(cprop, "MeshLoopTriangle");
2154         srna = RNA_def_struct(brna, "MeshLoopTriangles", NULL);
2155         RNA_def_struct_sdna(srna, "Mesh");
2156         RNA_def_struct_ui_text(srna, "Mesh Loop Triangles", "Tessellation of mesh polygons into triangles");
2157 }
2158
2159 /* mesh.loops */
2160 static void rna_def_mesh_loops(BlenderRNA *brna, PropertyRNA *cprop)
2161 {
2162         StructRNA *srna;
2163
2164         /*PropertyRNA *prop;*/
2165
2166         FunctionRNA *func;
2167         PropertyRNA *parm;
2168
2169         RNA_def_property_srna(cprop, "MeshLoops");
2170         srna = RNA_def_struct(brna, "MeshLoops", NULL);
2171         RNA_def_struct_sdna(srna, "Mesh");
2172         RNA_def_struct_ui_text(srna, "Mesh Loops", "Collection of mesh loops");
2173
2174         func = RNA_def_function(srna, "add", "ED_mesh_loops_add");
2175         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2176         parm = RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of loops to add", 0, INT_MAX);
2177         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2178 }
2179
2180 /* mesh.polygons */
2181 static void rna_def_mesh_polygons(BlenderRNA *brna, PropertyRNA *cprop)
2182 {
2183         StructRNA *srna;
2184
2185         PropertyRNA *prop;
2186
2187         FunctionRNA *func;
2188         PropertyRNA *parm;
2189
2190         RNA_def_property_srna(cprop, "MeshPolygons");
2191         srna = RNA_def_struct(brna, "MeshPolygons", NULL);
2192         RNA_def_struct_sdna(srna, "Mesh");
2193         RNA_def_struct_ui_text(srna, "Mesh Polygons", "Collection of mesh polygons");
2194
2195         prop = RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
2196         RNA_def_property_int_sdna(prop, NULL, "act_face");
2197         RNA_def_property_ui_text(prop, "Active Polygon", "The active polygon for this mesh");
2198
2199         func = RNA_def_function(srna, "add", "ED_mesh_polys_add");
2200         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2201         parm = RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of polygons to add", 0, INT_MAX);
2202         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2203 }
2204
2205
2206 static void rna_def_loop_colors(BlenderRNA *brna, PropertyRNA *cprop)
2207 {
2208         StructRNA *srna;
2209         PropertyRNA *prop;
2210
2211         FunctionRNA *func;
2212         PropertyRNA *parm;
2213
2214         RNA_def_property_srna(cprop, "LoopColors");
2215         srna = RNA_def_struct(brna, "LoopColors", NULL);
2216         RNA_def_struct_sdna(srna, "Mesh");
2217         RNA_def_struct_ui_text(srna, "Loop Colors", "Collection of vertex colors");
2218
2219         func = RNA_def_function(srna, "new", "rna_Mesh_vertex_color_new");
2220         RNA_def_function_ui_description(func, "Add a vertex color layer to Mesh");
2221         RNA_def_string(func, "name", "Col", 0, "", "Vertex color name");
2222         parm = RNA_def_pointer(func, "layer", "MeshLoopColorLayer", "", "The newly created layer");
2223         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2224         RNA_def_function_return(func, parm);
2225
2226         func = RNA_def_function(srna, "remove", "rna_Mesh_vertex_color_remove");
2227         RNA_def_function_ui_description(func, "Remove a vertex color layer");
2228         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2229         parm = RNA_def_pointer(func, "layer", "MeshLoopColorLayer", "", "The layer to remove");
2230         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
2231         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2232
2233         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2234         RNA_def_property_struct_type(prop, "MeshLoopColorLayer");
2235         RNA_def_property_pointer_funcs(prop, "rna_Mesh_vertex_color_active_get",
2236                                        "rna_Mesh_vertex_color_active_set", NULL, NULL);
2237         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
2238         RNA_def_property_ui_text(prop, "Active Vertex Color Layer", "Active vertex color layer");
2239         RNA_def_property_update(prop, 0, "rna_Mesh_update_data_edit_active_color");
2240
2241         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2242         RNA_def_property_int_funcs(prop, "rna_Mesh_vertex_color_active_index_get",
2243                                    "rna_Mesh_vertex_color_active_index_set", "rna_Mesh_vertex_color_index_range");
2244         RNA_def_property_ui_text(prop, "Active Vertex Color Index", "Active vertex color index");
2245         RNA_def_property_update(prop, 0, "rna_Mesh_update_data_edit_active_color");
2246 }
2247
2248 static void rna_def_uv_layers(BlenderRNA *brna, PropertyRNA *cprop)
2249 {
2250         StructRNA *srna;
2251         PropertyRNA *prop;
2252
2253         FunctionRNA *func;
2254         PropertyRNA *parm;
2255
2256         RNA_def_property_srna(cprop, "UVLoopLayers");
2257         srna = RNA_def_struct(brna, "UVLoopLayers", NULL);
2258         RNA_def_struct_sdna(srna, "Mesh");
2259         RNA_def_struct_ui_text(srna, "UV Loop Layers", "Collection of uv loop layers");
2260
2261         func = RNA_def_function(srna, "new", "rna_Mesh_uv_layers_new");
2262         RNA_def_function_ui_description(func, "Add a UV map layer to Mesh");
2263         RNA_def_string(func, "name", "UVMap", 0, "", "UV map name");
2264         parm = RNA_def_pointer(func, "layer", "MeshUVLoopLayer", "", "The newly created layer");
2265         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2266         RNA_def_function_return(func, parm);
2267
2268         func = RNA_def_function(srna, "remove", "rna_Mesh_uv_layers_remove");
2269         RNA_def_function_ui_description(func, "Remove a vertex color layer");
2270         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2271         parm = RNA_def_pointer(func, "layer", "MeshUVLoopLayer", "", "The layer to remove");
2272         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
2273
2274         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2275         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2276         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_active_get",
2277                                        "rna_Mesh_uv_layer_active_set", NULL, NULL);
2278         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
2279         RNA_def_property_ui_text(prop, "Active UV loop layer", "Active UV loop layer");
2280         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2281
2282         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2283         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_active_index_get",
2284                                    "rna_Mesh_uv_layer_active_index_set", "rna_Mesh_uv_layer_index_range");
2285         RNA_def_property_ui_text(prop, "Active UV loop layer Index", "Active UV loop layer index");
2286         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2287 }
2288
2289 /* mesh float layers */
2290 static void rna_def_vertex_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
2291 {
2292         StructRNA *srna;
2293
2294         FunctionRNA *func;
2295         PropertyRNA *parm;
2296
2297         RNA_def_property_srna(cprop, "VertexFloatProperties");
2298         srna = RNA_def_struct(brna, "VertexFloatProperties", NULL);
2299         RNA_def_struct_sdna(srna, "Mesh");
2300         RNA_def_struct_ui_text(srna, "Vertex Float Properties", "Collection of float properties");
2301
2302         func = RNA_def_function(srna, "new", "rna_Mesh_vertex_float_property_new");
2303         RNA_def_function_ui_description(func, "Add a float property layer to Mesh");
2304         RNA_def_string(func, "name", "Float Prop", 0, "", "Float property name");
2305         parm = RNA_def_pointer(func, "layer", "MeshVertexFloatPropertyLayer", "", "The newly created layer");
2306         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2307         RNA_def_function_return(func, parm);
2308 }
2309
2310 /* mesh int layers */
2311 static void rna_def_vertex_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
2312 {
2313         StructRNA *srna;
2314
2315         FunctionRNA *func;
2316         PropertyRNA *parm;
2317
2318         RNA_def_property_srna(cprop, "VertexIntProperties");
2319         srna = RNA_def_struct(brna, "VertexIntProperties", NULL);
2320         RNA_def_struct_sdna(srna, "Mesh");
2321         RNA_def_struct_ui_text(srna, "Vertex Int Properties", "Collection of int properties");
2322
2323         func = RNA_def_function(srna, "new", "rna_Mesh_vertex_int_property_new");
2324         RNA_def_function_ui_description(func, "Add a integer property layer to Mesh");
2325         RNA_def_string(func, "name", "Int Prop", 0, "",  "Int property name");
2326         parm = RNA_def_pointer(func, "layer", "MeshVertexIntPropertyLayer", "", "The newly created layer");
2327         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2328         RNA_def_function_return(func, parm);
2329 }
2330
2331 /* mesh string layers */
2332 static void rna_def_vertex_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
2333 {
2334         StructRNA *srna;
2335
2336         FunctionRNA *func;
2337         PropertyRNA *parm;
2338
2339         RNA_def_property_srna(cprop, "VertexStringProperties");
2340         srna = RNA_def_struct(brna, "VertexStringProperties", NULL);
2341         RNA_def_struct_sdna(srna, "Mesh");
2342         RNA_def_struct_ui_text(srna, "Vertex String Properties", "Collection of string properties");
2343
2344         func = RNA_def_function(srna, "new", "rna_Mesh_vertex_string_property_new");
2345         RNA_def_function_ui_description(func, "Add a string property layer to Mesh");
2346         RNA_def_string(func, "name", "String Prop", 0, "", "String property name");
2347         parm = RNA_def_pointer(func, "layer", "MeshVertexStringPropertyLayer", "", "The newly created layer");
2348         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2349         RNA_def_function_return(func, parm);
2350 }
2351
2352 /* mesh float layers */
2353 static void rna_def_polygon_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
2354 {
2355         StructRNA *srna;
2356
2357         FunctionRNA *func;
2358         PropertyRNA *parm;
2359
2360         RNA_def_property_srna(cprop, "PolygonFloatProperties");
2361         srna = RNA_def_struct(brna, "PolygonFloatProperties", NULL);
2362         RNA_def_struct_sdna(srna, "Mesh");
2363         RNA_def_struct_ui_text(srna, "Polygon Float Properties", "Collection of float properties");
2364
2365         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_float_property_new");
2366         RNA_def_function_ui_description(func, "Add a float property layer to Mesh");
2367         RNA_def_string(func, "name", "Float Prop", 0, "", "Float property name");
2368         parm = RNA_def_pointer(func, "layer", "MeshPolygonFloatPropertyLayer", "", "The newly created layer");
2369         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2370         RNA_def_function_return(func, parm);
2371 }
2372
2373 /* mesh int layers */
2374 static void rna_def_polygon_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
2375 {
2376         StructRNA *srna;
2377
2378         FunctionRNA *func;
2379         PropertyRNA *parm;
2380
2381         RNA_def_property_srna(cprop, "PolygonIntProperties");
2382         srna = RNA_def_struct(brna, "PolygonIntProperties", NULL);
2383         RNA_def_struct_sdna(srna, "Mesh");
2384         RNA_def_struct_ui_text(srna, "Polygon Int Properties", "Collection of int properties");
2385
2386         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_int_property_new");
2387         RNA_def_function_ui_description(func, "Add a integer property layer to Mesh");
2388         RNA_def_string(func, "name", "Int Prop", 0, "",  "Int property name");
2389         parm = RNA_def_pointer(func, "layer", "MeshPolygonIntPropertyLayer", "", "The newly created layer");
2390         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2391         RNA_def_function_return(func, parm);
2392 }
2393
2394 /* mesh string layers */
2395 static void rna_def_polygon_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
2396 {
2397         StructRNA *srna;
2398
2399         FunctionRNA *func;
2400         PropertyRNA *parm;
2401
2402         RNA_def_property_srna(cprop, "PolygonStringProperties");
2403         srna = RNA_def_struct(brna, "PolygonStringProperties", NULL);
2404         RNA_def_struct_sdna(srna, "Mesh");
2405         RNA_def_struct_ui_text(srna, "Polygon String Properties", "Collection of string properties");
2406
2407         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_string_property_new");
2408         RNA_def_function_ui_description(func, "Add a string property layer to Mesh");
2409         RNA_def_string(func, "name", "String Prop", 0, "", "String property name");
2410         parm = RNA_def_pointer(func, "layer", "MeshPolygonStringPropertyLayer", "", "The newly created layer");
2411         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2412         RNA_def_function_return(func, parm);
2413 }
2414
2415 static void rna_def_skin_vertices(BlenderRNA *brna, PropertyRNA *UNUSED(cprop))
2416 {
2417         StructRNA *srna;
2418         PropertyRNA *prop;
2419
2420         srna = RNA_def_struct(brna, "MeshSkinVertexLayer", NULL);
2421         RNA_def_struct_ui_text(srna, "Mesh Skin Vertex Layer", "Per-vertex skin data for use with the Skin modifier");
2422         RNA_def_struct_sdna(srna, "CustomDataLayer");
2423         RNA_def_struct_path_func(srna, "rna_MeshSkinVertexLayer_path");
2424
2425         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2426         RNA_def_struct_name_property(srna, prop);
2427         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshVertexLayer_name_set");
2428         RNA_def_property_ui_text(prop, "Name", "Name of skin layer");
2429         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2430
2431         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2432         RNA_def_property_struct_type(prop, "MeshSkinVertex");
2433         RNA_def_property_ui_text(prop, "Data", "");
2434         RNA_def_property_collection_funcs(prop, "rna_MeshSkinVertexLayer_data_begin", "rna_iterator_array_next",
2435                                           "rna_iterator_array_end", "rna_iterator_array_get",
2436                                           "rna_MeshSkinVertexLayer_data_length", NULL, NULL, NULL);
2437
2438         /* SkinVertex struct */
2439         srna = RNA_def_struct(brna, "MeshSkinVertex", NULL);
2440         RNA_def_struct_sdna(srna, "MVertSkin");
2441         RNA_def_struct_ui_text(srna, "Skin Vertex", "Per-vertex skin data for use with the Skin modifier");
2442         RNA_def_struct_path_func(srna, "rna_MeshSkinVertex_path");
2443
2444         prop = RNA_def_property(srna, "radius", PROP_FLOAT, PROP_UNSIGNED);
2445         RNA_def_property_array(prop, 2);
2446         RNA_def_property_ui_range(prop, 0.001, 100.0, 1, 3);
2447         RNA_def_property_ui_text(prop, "Radius", "Radius of the skin");
2448         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2449
2450         /* Flags */
2451
2452         prop = RNA_def_property(srna, "use_root", PROP_BOOLEAN, PROP_NONE);
2453         RNA_def_property_boolean_sdna(prop, NULL, "flag", MVERT_SKIN_ROOT);
2454         RNA_def_property_ui_text(prop, "Root",
2455                                  "Vertex is a root for rotation calculations and armature generation, "
2456                                  "setting this flag does not clear other roots in the same mesh island");
2457         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2458
2459         prop = RNA_def_property(srna, "use_loose", PROP_BOOLEAN, PROP_NONE);
2460         RNA_def_property_boolean_sdna(prop, NULL, "flag", MVERT_SKIN_LOOSE);
2461         RNA_def_property_ui_text(prop, "Loose", "If vertex has multiple adjacent edges, it is hulled to them directly");
2462         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2463 }
2464
2465 static void rna_def_paint_mask(BlenderRNA *brna, PropertyRNA *UNUSED(cprop))
2466 {
2467         StructRNA *srna;
2468         PropertyRNA *prop;
2469
2470         srna = RNA_def_struct(brna, "MeshPaintMaskLayer", NULL);
2471         RNA_def_struct_ui_text(srna, "Mesh Paint Mask Layer", "Per-vertex paint mask data");
2472         RNA_def_struct_sdna(srna, "CustomDataLayer");
2473         RNA_def_struct_path_func(srna, "rna_MeshPaintMaskLayer_path");
2474
2475         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2476         RNA_def_property_struct_type(prop, "MeshPaintMaskProperty");
2477         RNA_def_property_ui_text(prop, "Data", "");
2478
2479         RNA_def_property_collection_funcs(prop, "rna_MeshPaintMaskLayer_data_begin", "rna_iterator_array_next",
2480                                           "rna_iterator_array_end", "rna_iterator_array_get",
2481                                           "rna_MeshPaintMaskLayer_data_length", NULL, NULL, NULL);
2482
2483         srna = RNA_def_struct(brna, "MeshPaintMaskProperty", NULL);
2484         RNA_def_struct_sdna(srna, "MFloatProperty");
2485         RNA_def_struct_ui_text(srna, "Mesh Paint Mask Property",
2486                                "Floating point paint mask value");
2487         RNA_def_struct_path_func(srna, "rna_MeshPaintMask_path");
2488
2489         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
2490         RNA_def_property_float_sdna(prop, NULL, "f");
2491         RNA_def_property_ui_text(prop, "Value", "");
2492         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2493 }
2494
2495 static void rna_def_face_map(BlenderRNA *brna)
2496 {
2497         StructRNA *srna;
2498         PropertyRNA *prop;
2499
2500         srna = RNA_def_struct(brna, "MeshFaceMapLayer", NULL);
2501         RNA_def_struct_ui_text(srna, "Mesh Face Map Layer", "Per-face map index");
2502         RNA_def_struct_sdna(srna, "CustomDataLayer");
2503         RNA_def_struct_path_func(srna, "rna_MeshFaceMapLayer_path");
2504
2505         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2506         RNA_def_struct_name_property(srna, prop);
2507         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshPolyLayer_name_set");
2508         RNA_def_property_ui_text(prop, "Name", "Name of face-map layer");
2509         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2510
2511         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2512         RNA_def_property_struct_type(prop, "MeshFaceMap");
2513         RNA_def_property_ui_text(prop, "Data", "");
2514         RNA_def_property_collection_funcs(prop, "rna_MeshFaceMapLayer_data_begin", "rna_iterator_array_next",
2515                                           "rna_iterator_array_end", "rna_iterator_array_get",
2516                                           "rna_MeshFaceMapLayer_data_length", NULL, NULL, NULL);
2517
2518         /* FaceMap struct */
2519         srna = RNA_def_struct(brna, "MeshFaceMap", NULL);
2520         RNA_def_struct_sdna(srna, "MIntProperty");
2521         RNA_def_struct_ui_text(srna, "Int Property", "");
2522         RNA_def_struct_path_func(srna, "rna_MeshFaceMap_path");
2523
2524         prop = RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
2525         RNA_def_property_int_sdna(prop, NULL, "i");
2526         RNA_def_property_ui_text(prop, "Value", "");
2527         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2528 }
2529
2530 static void rna_def_face_maps(BlenderRNA *brna, PropertyRNA *cprop)
2531 {
2532         StructRNA *srna;
2533         PropertyRNA *prop;
2534
2535         RNA_def_property_srna(cprop, "MeshFaceMapLayers");
2536         srna = RNA_def_struct(brna, "MeshFaceMapLayers", NULL);
2537         RNA_def_struct_ui_text(srna, "Mesh Face Map Layer", "Per-face map index");
2538         RNA_def_struct_sdna(srna, "Mesh");
2539         RNA_def_struct_ui_text(srna, "Mesh FaceMaps", "Collection of mesh face-maps");
2540
2541         /* add this since we only ever have one layer anyway, don't bother with active_index */
2542         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2543         RNA_def_property_struct_type(prop, "MeshFaceMapLayer");
2544         RNA_def_property_pointer_funcs(prop, "rna_Mesh_face_map_active_get",
2545                                        NULL, NULL, NULL);
2546         RNA_def_property_ui_text(prop, "Active FaceMap Layer", "");
2547         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2548
2549         FunctionRNA *func;
2550         PropertyRNA *parm;
2551
2552         func = RNA_def_function(srna, "new", "rna_Mesh_face_map_new");
2553         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2554         RNA_def_function_ui_description(func, "Add a float property layer to Mesh");
2555         RNA_def_string(func, "name", "Face Map", 0, "", "Face map name");
2556         parm = RNA_def_pointer(func, "layer", "MeshFaceMapLayer", "", "The newly created layer");
2557         RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2558         RNA_def_function_return(func, parm);
2559
2560         func = RNA_def_function(srna, "remove", "rna_Mesh_face_map_remove");
2561         RNA_def_function_ui_description(func, "Remove a face map layer");
2562         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2563         parm = RNA_def_pointer(func, "layer", "MeshFaceMapLayer", "", "The layer to remove");
2564         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
2565         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2566 }
2567
2568 static void rna_def_mesh(BlenderRNA *brna)
2569 {
2570         StructRNA *srna;
2571         PropertyRNA *prop;
2572
2573         srna = RNA_def_struct(brna, "Mesh", "ID");
2574         RNA_def_struct_ui_text(srna, "Mesh", "Mesh data-block defining geometric surfaces");
2575         RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
2576
2577         prop = RNA_def_property(srna, "vertices", PROP_COLLECTION, PROP_NONE);
2578         RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
2579         RNA_def_property_struct_type(prop, "MeshVertex");
2580         RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh");
2581         rna_def_mesh_vertices(brna, prop);
2582
2583         prop = RNA_def_property(srna, "edges", PROP_COLLECTION, PROP_NONE);
2584         RNA_def_property_collection_sdna(prop, NULL, "medge", "totedge");
2585         RNA_def_property_struct_type(prop, "MeshEdge");
2586         RNA_def_property_ui_text(prop, "Edges", "Edges of the mesh");
2587         rna_def_mesh_edges(brna, prop);
2588
2589         prop = RNA_def_property(srna, "loops", PROP_COLLECTION, PROP_NONE);
2590         RNA_def_property_collection_sdna(prop, NULL, "mloop", "totloop");
2591         RNA_def_property_struct_type(prop, "MeshLoop");
2592         RNA_def_property_ui_text(prop, "Loops", "Loops of the mesh (polygon corners)");
2593         rna_def_mesh_loops(brna, prop);
2594
2595         prop = RNA_def_property(srna, "polygons", PROP_COLLECTION, PROP_NONE);
2596         RNA_def_property_collection_sdna(prop, NULL, "mpoly", "totpoly");
2597         RNA_def_property_struct_type(prop, "MeshPolygon");
2598         RNA_def_property_ui_text(prop, "Polygons", "Polygons of the mesh");
2599         rna_def_mesh_polygons(brna, prop);
2600
2601         prop = RNA_def_property(srna, "loop_triangles", PROP_COLLECTION, PROP_NONE);
2602         RNA_def_property_collection_sdna(prop, NULL, "runtime.looptris.array", "runtime.looptris.len");
2603         RNA_def_property_struct_type(prop, "MeshLoopTriangle");
2604         RNA_def_property_ui_text(prop, "Loop Triangles", "Tessellation of mesh polygons into triangles");
2605         rna_def_mesh_looptris(brna, prop);
2606
2607         /* TODO, should this be allowed to be its self? */
2608         prop = RNA_def_property(srna, "texture_mesh", PROP_POINTER, PROP_NONE);
2609         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
2610         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2611         RNA_def_property_ui_text(prop, "Texture Mesh",
2612                                  "Use another mesh for texture indices (vertex indices must be aligned)");
2613
2614         /* UV loop layers */
2615         prop = RNA_def_property(srna, "uv_layers", PROP_COLLECTION, PROP_NONE);
2616         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
2617         RNA_def_property_collection_funcs(prop, "rna_Mesh_uv_layers_begin", NULL, NULL, NULL,
2618                                           "rna_Mesh_uv_layers_length", NULL, NULL, NULL);
2619         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2620         RNA_def_property_ui_text(prop, "UV Loop Layers", "All UV loop layers");
2621         rna_def_uv_layers(brna, prop);
2622
2623         prop = RNA_def_property(srna, "uv_layer_clone", PROP_POINTER, PROP_NONE);
2624         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2625         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_clone_get",
2626                                        "rna_Mesh_uv_layer_clone_set", NULL, NULL);
2627         RNA_def_property_flag(prop, PROP_EDITABLE);
2628         RNA_def_property_ui_text(prop, "Clone UV loop layer", "UV loop layer to be used as cloning source");
2629
2630         prop = RNA_def_property(srna, "uv_layer_clone_index", PROP_INT, PROP_UNSIGNED);
2631         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_clone_index_get",
2632                                    "rna_Mesh_uv_layer_clone_index_set", "rna_Mesh_uv_layer_index_range");
2633         RNA_def_property_ui_text(prop, "Clone UV loop layer Index", "Clone UV loop layer index");
2634
2635         prop = RNA_def_property(srna, "uv_layer_stencil", PROP_POINTER, PROP_NONE);
2636         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2637         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_stencil_get",
2638                                        "rna_Mesh_uv_layer_stencil_set", NULL, NULL);
2639         RNA_def_property_flag(prop, PROP_EDITABLE);
2640         RNA_def_property_ui_text(prop, "Mask UV loop layer", "UV loop layer to mask the painted area");
2641
2642         prop = RNA_def_property(srna, "uv_layer_stencil_index", PROP_INT, PROP_UNSIGNED);
2643         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_stencil_index_get",
2644                                    "rna_Mesh_uv_layer_stencil_index_set", "rna_Mesh_uv_layer_index_range");
2645         RNA_def_property_ui_text(prop, "Mask UV loop layer Index", "Mask UV loop layer index");
2646
2647         /* Vertex colors */
2648
2649         prop = RNA_def_property(srna, "vertex_colors", PROP_COLLECTION, PROP_NONE);
2650         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
2651         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_colors_begin", NULL, NULL, NULL,
2652                                           "rna_Mesh_vertex_colors_length", NULL, NULL, NULL);
2653         RNA_def_property_struct_type(prop, "MeshLoopColorLayer");
2654         RNA_def_property_ui_text(prop, "Vertex Colors", "All vertex colors");
2655         rna_def_loop_colors(brna, prop);
2656
2657         /* TODO, edge customdata layers (bmesh py api can access already) */
2658         prop = RNA_def_property(srna, "vertex_layers_float", PROP_COLLECTION, PROP_NONE);
2659         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2660         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_float_layers_begin", NULL, NULL, NULL,
2661                                           "rna_Mesh_vertex_float_layers_length", NULL, NULL, NULL);
2662         RNA_def_property_struct_type(prop, "MeshVertexFloatPropertyLayer");
2663         RNA_def_property_ui_text(prop, "Float Property Layers", "");
2664         rna_def_vertex_float_layers(brna, prop);
2665
2666         prop = RNA_def_property(srna, "vertex_layers_int", PROP_COLLECTION, PROP_NONE);
2667         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2668         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_int_layers_begin", NULL, NULL, NULL,
2669                                           "rna_Mesh_vertex_int_layers_length", NULL, NULL, NULL);
2670         RNA_def_property_struct_type(prop, "MeshVertexIntPropertyLayer");
2671         RNA_def_property_ui_text(prop, "Int Property Layers", "");
2672         rna_def_vertex_int_layers(brna, prop);
2673
2674         prop = RNA_def_property(srna, "vertex_layers_string", PROP_COLLECTION, PROP_NONE);
2675         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2676         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_string_layers_begin", NULL, NULL, NULL,
2677                                           "rna_Mesh_vertex_string_layers_length", NULL, NULL, NULL);
2678         RNA_def_property_struct_type(prop, "MeshVertexStringPropertyLayer");
2679         RNA_def_property_ui_text(prop, "String Property Layers", "");
2680         rna_def_vertex_string_layers(brna, prop);
2681
2682         prop = RNA_def_property(srna, "polygon_layers_float", PROP_COLLECTION, PROP_NONE);
2683         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2684         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_float_layers_begin", NULL, NULL, NULL,
2685                                           "rna_Mesh_polygon_float_layers_length", NULL, NULL, NULL);
2686         RNA_def_property_struct_type(prop, "MeshPolygonFloatPropertyLayer");
2687         RNA_def_property_ui_text(prop, "Float Property Layers", "");
2688         rna_def_polygon_float_layers(brna, prop);
2689
2690         prop = RNA_def_property(srna, "polygon_layers_int", PROP_COLLECTION, PROP_NONE);
2691         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2692         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_int_layers_begin", NULL, NULL, NULL,
2693                                           "rna_Mesh_polygon_int_layers_length", NULL, NULL, NULL);
2694         RNA_def_property_struct_type(prop, "MeshPolygonIntPropertyLayer");
2695         RNA_def_property_ui_text(prop, "Int Property Layers", "");
2696         rna_def_polygon_int_layers(brna, prop);
2697
2698         prop = RNA_def_property(srna, "polygon_layers_string", PROP_COLLECTION, PROP_NONE);
2699         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2700         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_string_layers_begin", NULL, NULL, NULL,
2701                                           "rna_Mesh_polygon_string_layers_length", NULL, NULL, NULL);
2702         RNA_def_property_struct_type(prop, "MeshPolygonStringPropertyLayer");
2703         RNA_def_property_ui_text(prop, "String Property Layers", "");
2704         rna_def_polygon_string_layers(brna, prop);
2705
2706         /* face-maps */
2707         prop = RNA_def_property(srna, "face_maps", PROP_COLLECTION, PROP_NONE);
2708         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2709         RNA_def_property_collection_funcs(prop, "rna_Mesh_face_maps_begin", NULL, NULL, NULL,
2710                                           "rna_Mesh_face_maps_length", NULL, NULL, NULL);
2711         RNA_def_property_struct_type(prop, "MeshFaceMapLayer");
2712         RNA_def_property_ui_text(prop, "FaceMap", "");
2713         rna_def_face_maps(brna, prop);
2714
2715         /* Skin vertices */
2716         prop = RNA_def_property(srna, "skin_vertices", PROP_COLLECTION, PROP_NONE);
2717         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2718         RNA_def_property_collection_funcs(prop, "rna_Mesh_skin_vertices_begin", NULL, NULL, NULL,
2719                                           "rna_Mesh_skin_vertices_length", NULL, NULL, NULL);
2720         RNA_def_property_struct_type(prop, "MeshSkinVertexLayer");
2721         RNA_def_property_ui_text(prop, "Skin Vertices", "All skin vertices");
2722         rna_def_skin_vertices(brna, prop);
2723         /* End skin vertices */
2724
2725         /* Paint mask */
2726         prop = RNA_def_property(srna, "vertex_paint_masks", PROP_COLLECTION, PROP_NONE);
2727         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2728         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_paint_masks_begin", NULL, NULL, NULL,
2729                                           "rna_Mesh_vertex_paint_masks_length", NULL, NULL, NULL);
2730         RNA_def_property_struct_type(prop, "MeshPaintMaskLayer");
2731         RNA_def_property_ui_text(prop, "Vertex Paint Mask", "Vertex paint mask");
2732         rna_def_paint_mask(brna, prop);
2733         /* End paint mask */
2734
2735         prop = RNA_def_property(srna, "use_auto_smooth", PROP_BOOLEAN, PROP_NONE);
2736         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_AUTOSMOOTH);
2737         RNA_def_property_ui_text(prop, "Auto Smooth",
2738                                  "Auto smooth (based on smooth/sharp faces/edges and angle between faces), "
2739                                  "or use custom split normals data if available");
2740         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2741
2742         prop = RNA_def_property(srna, "auto_smooth_angle", PROP_FLOAT, PROP_ANGLE);
2743         RNA_def_property_float_sdna(prop, NULL, "smoothresh");
2744         RNA_def_property_float_default(prop, DEG2RADF(180.0f));
2745         RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
2746         RNA_def_property_ui_text(prop, "Auto Smooth Angle",
2747                                  "Maximum angle between face normals that will be considered as smooth "
2748                                  "(unused if custom split normals data are available)");
2749         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2750
2751         RNA_define_verify_sdna(false);
2752         prop = RNA_def_property(srna, "has_custom_normals", PROP_BOOLEAN, PROP_NONE);
2753         RNA_def_property_boolean_sdna(prop, NULL, "", 0);
2754         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2755         RNA_def_property_ui_text(prop, "Has Custom Normals",
2756                                  "True if there are custom split normals data in this mesh");
2757         RNA_def_property_boolean_funcs(prop, "rna_Mesh_has_custom_normals_get", NULL);
2758         RNA_define_verify_sdna(true);
2759
2760         prop = RNA_def_property(srna, "show_double_sided", PROP_BOOLEAN, PROP_NONE);
2761         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_TWOSIDED);
2762         RNA_def_property_ui_text(prop, "Double Sided", "Display the mesh with double or single sided lighting (OpenGL only)");
2763         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2764
2765         prop = RNA_def_property(srna, "texco_mesh", PROP_POINTER, PROP_NONE);
2766         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
2767         RNA_def_property_flag(prop, PROP_EDITABLE);
2768         RNA_def_property_ui_text(prop, "Texture Space Mesh", "Derive texture coordinates from another mesh");
2769
2770         prop = RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
2771         RNA_def_property_pointer_sdna(prop, NULL, "key");
2772         RNA_def_property_ui_text(prop, "Shape Keys", "");
2773
2774         /* texture space */
2775         prop = RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
2776         RNA_def_property_boolean_sdna(prop, NULL, "texflag", ME_AUTOSPACE);
2777         RNA_def_property_ui_text(prop, "Auto Texture Space",
2778                                  "Adjust active object's texture space automatically when transforming object");
2779
2780 #if 0
2781         prop = RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
2782         RNA_def_property_array(prop, 3);
2783         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
2784         RNA_def_property_editable_func(prop, "rna_Mesh_texspace_editable");
2785         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_loc_get", "rna_Mesh_texspace_loc_set", NULL);
2786         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2787 #endif
2788
2789         /* not supported yet */
2790 #if 0
2791         prop = RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
2792         RNA_def_property_float(prop, NULL, "rot");
2793         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
2794         RNA_def_property_editable_func(prop, texspace_editable);
2795         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2796 #endif
2797
2798         /* editflag */
2799         prop = RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
2800         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_X);
2801         RNA_def_property_ui_text(prop, "X Mirror", "X Axis mirror editing");
2802         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2803
2804 #if 0
2805         prop = RNA_def_property(srna, "use_mirror_y", PROP_BOOLEAN, PROP_NONE);
2806         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Y);
2807         RNA_def_property_ui_text(prop, "Y Mirror", "Y Axis mirror editing");
2808
2809         prop = RNA_def_property(srna, "use_mirror_z", PROP_BOOLEAN, PROP_NONE);
2810         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Z);
2811         RNA_def_property_ui_text(prop, "Z Mirror", "Z Axis mirror editing");
2812 #endif
2813
2814         prop = RNA_def_property(srna, "use_mirror_topology", PROP_BOOLEAN, PROP_NONE);
2815         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_TOPO);
2816         RNA_def_property_ui_text(prop, "Topology Mirror",
2817                                  "Use topology based mirroring "
2818                                  "(for when both sides of mesh have matching, unique topology)");
2819
2820         prop = RNA_def_property(srna, "use_paint_mask", PROP_BOOLEAN, PROP_NONE);
2821         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_PAINT_FACE_SEL);
2822         RNA_def_property_ui_text(prop, "Paint Mask", "Face selection masking for painting");
2823         RNA_def_property_ui_icon(prop, ICON_FACESEL, 0);
2824         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Mesh_update_facemask");
2825
2826         prop = RNA_def_property(srna, "use_paint_mask_vertex", PROP_BOOLEAN, PROP_NONE);
2827         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_PAINT_VERT_SEL);
2828         RNA_def_property_ui_text(prop, "Vertex Selection", "Vertex selection masking for painting (weight paint only)");
2829         RNA_def_property_ui_icon(prop, ICON_VERTEXSEL, 0);
2830         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Mesh_update_vertmask");
2831
2832
2833
2834         /* customdata flags */
2835         prop = RNA_def_property(srna, "use_customdata_vertex_bevel", PROP_BOOLEAN, PROP_NONE);
2836         RNA_def_property_boolean_sdna(prop, NULL, "cd_flag", ME_CDFLAG_VERT_BWEIGHT);
2837         RNA_def_property_ui_text(prop, "Store Vertex Bevel Weight", "");
2838
2839         prop = RNA_def_property(srna, "use_customdata_edge_bevel", PROP_BOOLEAN, PROP_NONE);
2840         RNA_def_property_boolean_sdna(prop, NULL, "cd_flag", ME_CDFLAG_EDGE_BWEIGHT);
2841         RNA_def_property_ui_text(prop, "Store Edge Bevel Weight", "");
2842
2843         prop = RNA_def_property(srna, "use_customdata_edge_crease", PROP_BOOLEAN, PROP_NONE);
2844         RNA_def_property_boolean_sdna(prop, NULL, "cd_flag", ME_CDFLAG_EDGE_CREASE);
2845         RNA_def_property_ui_text(prop, "Store Edge Crease", "");
2846
2847
2848         /* readonly editmesh info - use for extrude menu */
2849         prop = RNA_def_property(srna, "total_vert_sel", PROP_INT, PROP_UNSIGNED);
2850         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_vert_get", NULL, NULL);
2851         RNA_def_property_ui_text(prop, "Selected Vert Total", "Selected vertex count in editmode");
2852         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2853
2854         prop = RNA_def_property(srna, "total_edge_sel", PROP_INT, PROP_UNSIGNED);
2855         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_edge_get", NULL, NULL);
2856         RNA_def_property_ui_text(prop, "Selected Edge Total", "Selected edge count in editmode");
2857         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2858
2859         prop = RNA_def_property(srna, "total_face_sel", PROP_INT, PROP_UNSIGNED);
2860         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_face_get", NULL, NULL);
2861         RNA_def_property_ui_text(prop, "Selected Face Total", "Selected face count in editmode");
2862         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2863
2864         prop = RNA_def_property(srna, "is_editmode", PROP_BOOLEAN, PROP_NONE);
2865         RNA_def_property_boolean_funcs(prop, "rna_Mesh_is_editmode_get", NULL);
2866         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2867         RNA_def_property_ui_text(prop, "Is Editmode", "True when used in editmode");
2868
2869         /* pointers */
2870         rna_def_animdata_common(srna);
2871         rna_def_texmat_common(srna, "rna_Mesh_texspace_editable");
2872
2873         RNA_api_mesh(srna);
2874 }
2875
2876 void RNA_def_mesh(BlenderRNA *brna)
2877 {
2878         rna_def_mesh(brna);
2879         rna_def_mvert(brna);
2880         rna_def_mvert_group(brna);
2881         rna_def_medge(brna);
2882         rna_def_mlooptri(brna);
2883         rna_def_mloop(brna);
2884         rna_def_mpolygon(brna);
2885         rna_def_mloopuv(brna);
2886         rna_def_mloopcol(brna);
2887         rna_def_mproperties(brna);
2888         rna_def_face_map(brna);
2889 }
2890
2891 #endif