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