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