flush selection when switching weight paint vertex/face selection modes.
[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
32 #include <stdlib.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "RNA_access.h"
37 #include "RNA_define.h"
38 #include "RNA_types.h"
39
40 #include "rna_internal.h"
41
42 #include "DNA_material_types.h"
43 #include "DNA_mesh_types.h"
44 #include "DNA_meshdata_types.h"
45 #include "DNA_object_types.h"
46
47 #include "WM_types.h"
48
49 #include "BLI_array.h"
50 #include "BLI_math_base.h"
51 #include "BLI_math_rotation.h"
52
53 #ifdef RNA_RUNTIME
54
55 #include "DNA_scene_types.h"
56
57 #include "BLI_math.h"
58
59 #include "BKE_customdata.h"
60 #include "BKE_depsgraph.h"
61 #include "BKE_main.h"
62 #include "BKE_mesh.h"
63 #include "BKE_tessmesh.h"
64 #include "BKE_report.h"
65
66 #include "ED_mesh.h" /* XXX Bad level call */
67
68 #include "WM_api.h"
69 #include "WM_types.h"
70
71 #include "rna_mesh_utils.h"
72
73 static Mesh *rna_mesh(PointerRNA *ptr)
74 {
75         Mesh *me = (Mesh *)ptr->id.data;
76         return me;
77 }
78
79 static CustomData *rna_mesh_vdata_helper(Mesh *me)
80 {
81         return (me->edit_btmesh) ? &me->edit_btmesh->bm->vdata : &me->vdata;
82 }
83
84 static CustomData *rna_mesh_pdata_helper(Mesh *me)
85 {
86         return (me->edit_btmesh) ? &me->edit_btmesh->bm->pdata : &me->pdata;
87 }
88
89 static CustomData *rna_mesh_ldata_helper(Mesh *me)
90 {
91         return (me->edit_btmesh) ? &me->edit_btmesh->bm->ldata : &me->ldata;
92 }
93
94 static CustomData *rna_mesh_fdata_helper(Mesh *me)
95 {
96         return (me->edit_btmesh) ? NULL : &me->fdata;
97 }
98
99 static CustomData *rna_mesh_vdata(PointerRNA *ptr)
100 {
101         Mesh *me = rna_mesh(ptr);
102         return rna_mesh_vdata_helper(me);
103 }
104 static CustomData *rna_mesh_pdata(PointerRNA *ptr)
105 {
106         Mesh *me = rna_mesh(ptr);
107         return rna_mesh_pdata_helper(me);
108 }
109
110 static CustomData *rna_mesh_ldata(PointerRNA *ptr)
111 {
112         Mesh *me = rna_mesh(ptr);
113         return rna_mesh_ldata_helper(me);
114 }
115
116 static CustomData *rna_mesh_fdata(PointerRNA *ptr)
117 {
118         Mesh *me = rna_mesh(ptr);
119         return rna_mesh_fdata_helper(me);
120 }
121
122 static void rna_Mesh_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
123 {
124         ID *id = ptr->id.data;
125
126         /* cheating way for importers to avoid slow updates */
127         if (id->us > 0) {
128                 DAG_id_tag_update(id, 0);
129                 WM_main_add_notifier(NC_GEOM | ND_DATA, id);
130         }
131 }
132
133 static void rna_Mesh_update_select(Main *bmain, Scene *scene, PointerRNA *ptr)
134 {
135         ID *id = ptr->id.data;
136         /* cheating way for importers to avoid slow updates */
137         if (id->us > 0) {
138                 WM_main_add_notifier(NC_GEOM | ND_SELECT, id);
139         }
140 }
141
142 void rna_Mesh_update_draw(Main *bmain, Scene *scene, PointerRNA *ptr)
143 {
144         ID *id = ptr->id.data;
145         /* cheating way for importers to avoid slow updates */
146         if (id->us > 0) {
147                 WM_main_add_notifier(NC_GEOM | ND_DATA, id);
148         }
149 }
150
151
152 static void rna_Mesh_update_vertmask(Main *bmain, Scene *scene, PointerRNA *ptr)
153 {
154         Mesh *me = ptr->data;
155         if ((me->editflag & ME_EDIT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_MASK)) {
156                 me->editflag &= ~ME_EDIT_PAINT_MASK;
157                 BKE_mesh_flush_select_from_polys(me->mvert, me->totvert,
158                                                  me->mloop,
159                                                  me->medge, me->totedge,
160                                                  me->mpoly, me->totpoly);
161         }
162         rna_Mesh_update_draw(bmain, scene, ptr);
163 }
164
165 static void rna_Mesh_update_facemask(Main *bmain, Scene *scene, PointerRNA *ptr)
166 {
167         Mesh *me = ptr->data;
168         if ((me->editflag & ME_EDIT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_MASK)) {
169                 me->editflag &= ~ME_EDIT_VERT_SEL;
170                 BKE_mesh_flush_select_from_verts(me->mvert, me->totvert,
171                                                  me->mloop,
172                                                  me->medge, me->totedge,
173                                                  me->mpoly, me->totpoly);
174         }
175         rna_Mesh_update_draw(bmain, scene, ptr);
176 }
177 static void rna_MeshVertex_normal_get(PointerRNA *ptr, float *value)
178 {
179         MVert *mvert = (MVert *)ptr->data;
180         normal_short_to_float_v3(value, mvert->no);
181 }
182
183 static void rna_MeshVertex_normal_set(PointerRNA *ptr, const float *value)
184 {
185         MVert *mvert = (MVert *)ptr->data;
186         float no[3];
187
188         copy_v3_v3(no, value);
189         normalize_v3(no);
190         normal_float_to_short_v3(mvert->no, no);
191 }
192
193 static float rna_MeshVertex_bevel_weight_get(PointerRNA *ptr)
194 {
195         MVert *mvert = (MVert *)ptr->data;
196         return mvert->bweight / 255.0f;
197 }
198
199 static void rna_MeshVertex_bevel_weight_set(PointerRNA *ptr, float value)
200 {
201         MVert *mvert = (MVert *)ptr->data;
202         mvert->bweight = (char)(CLAMPIS(value * 255.0f, 0, 255));
203 }
204
205 static float rna_MEdge_bevel_weight_get(PointerRNA *ptr)
206 {
207         MEdge *medge = (MEdge *)ptr->data;
208         return medge->bweight / 255.0f;
209 }
210
211 static void rna_MEdge_bevel_weight_set(PointerRNA *ptr, float value)
212 {
213         MEdge *medge = (MEdge *)ptr->data;
214         medge->bweight = (char)(CLAMPIS(value * 255.0f, 0, 255));
215 }
216
217 static float rna_MEdge_crease_get(PointerRNA *ptr)
218 {
219         MEdge *medge = (MEdge *)ptr->data;
220         return medge->crease / 255.0f;
221 }
222
223 static void rna_MEdge_crease_set(PointerRNA *ptr, float value)
224 {
225         MEdge *medge = (MEdge *)ptr->data;
226         medge->crease = (char)(CLAMPIS(value * 255.0f, 0, 255));
227 }
228
229 static void rna_MeshPolygon_normal_get(PointerRNA *ptr, float *values)
230 {
231         Mesh *me = rna_mesh(ptr);
232         MPoly *mp = (MPoly *)ptr->data;
233
234         /* BMESH_TODO: might be faster to look for a CD_NORMALS layer and use that */
235         BKE_mesh_calc_poly_normal(mp, me->mloop + mp->loopstart, me->mvert, values);
236 }
237
238 static float rna_MeshPolygon_area_get(PointerRNA *ptr)
239 {
240         Mesh *me = (Mesh *)ptr->id.data;
241         MPoly *mp = (MPoly *)ptr->data;
242
243         return BKE_mesh_calc_poly_area(mp, me->mloop + mp->loopstart, me->mvert, NULL);
244 }
245
246 static void rna_MeshTessFace_normal_get(PointerRNA *ptr, float *values)
247 {
248         Mesh *me = rna_mesh(ptr);
249         MFace *mface = (MFace *)ptr->data;
250
251         if (mface->v4)
252                 normal_quad_v3(values, me->mvert[mface->v1].co, me->mvert[mface->v2].co,
253                                me->mvert[mface->v3].co, me->mvert[mface->v4].co);
254         else
255                 normal_tri_v3(values, me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co);
256 }
257
258 static float rna_MeshTessFace_area_get(PointerRNA *ptr)
259 {
260         Mesh *me = rna_mesh(ptr);
261         MFace *mface = (MFace *)ptr->data;
262
263         if (mface->v4)
264                 return area_quad_v3(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co,
265                                     me->mvert[mface->v4].co);
266         else
267                 return area_tri_v3(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co);
268 }
269
270 static void rna_MeshTextureFace_uv1_get(PointerRNA *ptr, float *values)
271 {
272         MTFace *mtface = (MTFace *)ptr->data;
273
274         values[0] = mtface->uv[0][0];
275         values[1] = mtface->uv[0][1];
276 }
277
278 static void rna_MeshTextureFace_uv1_set(PointerRNA *ptr, const float *values)
279 {
280         MTFace *mtface = (MTFace *)ptr->data;
281
282         mtface->uv[0][0] = values[0];
283         mtface->uv[0][1] = values[1];
284 }
285
286 static void rna_MeshTextureFace_uv2_get(PointerRNA *ptr, float *values)
287 {
288         MTFace *mtface = (MTFace *)ptr->data;
289
290         values[0] = mtface->uv[1][0];
291         values[1] = mtface->uv[1][1];
292 }
293
294 static void rna_MeshTextureFace_uv2_set(PointerRNA *ptr, const float *values)
295 {
296         MTFace *mtface = (MTFace *)ptr->data;
297
298         mtface->uv[1][0] = values[0];
299         mtface->uv[1][1] = values[1];
300 }
301
302 static void rna_MeshTextureFace_uv3_get(PointerRNA *ptr, float *values)
303 {
304         MTFace *mtface = (MTFace *)ptr->data;
305
306         values[0] = mtface->uv[2][0];
307         values[1] = mtface->uv[2][1];
308 }
309
310 static void rna_MeshTextureFace_uv3_set(PointerRNA *ptr, const float *values)
311 {
312         MTFace *mtface = (MTFace *)ptr->data;
313
314         mtface->uv[2][0] = values[0];
315         mtface->uv[2][1] = values[1];
316 }
317
318 static void rna_MeshTextureFace_uv4_get(PointerRNA *ptr, float *values)
319 {
320         MTFace *mtface = (MTFace *)ptr->data;
321
322         values[0] = mtface->uv[3][0];
323         values[1] = mtface->uv[3][1];
324 }
325
326 static void rna_MeshTextureFace_uv4_set(PointerRNA *ptr, const float *values)
327 {
328         MTFace *mtface = (MTFace *)ptr->data;
329
330         mtface->uv[3][0] = values[0];
331         mtface->uv[3][1] = values[1];
332 }
333
334 static int rna_CustomDataData_numverts(PointerRNA *ptr, int type)
335 {
336         Mesh *me = rna_mesh(ptr);
337         CustomData *fdata = rna_mesh_fdata(ptr);
338         CustomDataLayer *cdl;
339         int a, b;
340
341         for (cdl = fdata->layers, a = 0; a < fdata->totlayer; cdl++, a++) {
342                 if (cdl->type == type) {
343                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
344                         if (b >= 0 && b < me->totface) {
345                                 return (me->mface[b].v4 ? 4 : 3);
346                         }
347                 }
348         }
349
350         return 0;
351 }
352
353 static int rna_MeshTextureFace_uv_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
354 {
355         length[0] = rna_CustomDataData_numverts(ptr, CD_MTFACE);
356         length[1] = 2;
357         return length[0] * length[1];
358 }
359
360 static void rna_MeshTextureFace_uv_get(PointerRNA *ptr, float *values)
361 {
362         MTFace *mtface = (MTFace *)ptr->data;
363         int totvert = rna_CustomDataData_numverts(ptr, CD_MTFACE);
364
365         memcpy(values, mtface->uv, totvert * 2 * sizeof(float));
366 }
367
368 static void rna_MeshTextureFace_uv_set(PointerRNA *ptr, const float *values)
369 {
370         MTFace *mtface = (MTFace *)ptr->data;
371         int totvert = rna_CustomDataData_numverts(ptr, CD_MTFACE);
372
373         memcpy(mtface->uv, values, totvert * 2 * sizeof(float));
374 }
375
376 /* notice red and blue are swapped */
377 static void rna_MeshColor_color1_get(PointerRNA *ptr, float *values)
378 {
379         MCol *mcol = (MCol *)ptr->data;
380
381         values[2] = (&mcol[0].r)[0] / 255.0f;
382         values[1] = (&mcol[0].r)[1] / 255.0f;
383         values[0] = (&mcol[0].r)[2] / 255.0f;
384 }
385
386 static void rna_MeshColor_color1_set(PointerRNA *ptr, const float *values)
387 {
388         MCol *mcol = (MCol *)ptr->data;
389
390         (&mcol[0].r)[2] = (char)(CLAMPIS(values[0] * 255.0f, 0, 255));
391         (&mcol[0].r)[1] = (char)(CLAMPIS(values[1] * 255.0f, 0, 255));
392         (&mcol[0].r)[0] = (char)(CLAMPIS(values[2] * 255.0f, 0, 255));
393 }
394
395 static void rna_MeshColor_color2_get(PointerRNA *ptr, float *values)
396 {
397         MCol *mcol = (MCol *)ptr->data;
398
399         values[2] = (&mcol[1].r)[0] / 255.0f;
400         values[1] = (&mcol[1].r)[1] / 255.0f;
401         values[0] = (&mcol[1].r)[2] / 255.0f;
402 }
403
404 static void rna_MeshColor_color2_set(PointerRNA *ptr, const float *values)
405 {
406         MCol *mcol = (MCol *)ptr->data;
407
408         (&mcol[1].r)[2] = (char)(CLAMPIS(values[0] * 255.0f, 0, 255));
409         (&mcol[1].r)[1] = (char)(CLAMPIS(values[1] * 255.0f, 0, 255));
410         (&mcol[1].r)[0] = (char)(CLAMPIS(values[2] * 255.0f, 0, 255));
411 }
412
413 static void rna_MeshColor_color3_get(PointerRNA *ptr, float *values)
414 {
415         MCol *mcol = (MCol *)ptr->data;
416
417         values[2] = (&mcol[2].r)[0] / 255.0f;
418         values[1] = (&mcol[2].r)[1] / 255.0f;
419         values[0] = (&mcol[2].r)[2] / 255.0f;
420 }
421
422 static void rna_MeshColor_color3_set(PointerRNA *ptr, const float *values)
423 {
424         MCol *mcol = (MCol *)ptr->data;
425
426         (&mcol[2].r)[2] = (char)(CLAMPIS(values[0] * 255.0f, 0, 255));
427         (&mcol[2].r)[1] = (char)(CLAMPIS(values[1] * 255.0f, 0, 255));
428         (&mcol[2].r)[0] = (char)(CLAMPIS(values[2] * 255.0f, 0, 255));
429 }
430
431 static void rna_MeshColor_color4_get(PointerRNA *ptr, float *values)
432 {
433         MCol *mcol = (MCol *)ptr->data;
434
435         values[2] = (&mcol[3].r)[0] / 255.0f;
436         values[1] = (&mcol[3].r)[1] / 255.0f;
437         values[0] = (&mcol[3].r)[2] / 255.0f;
438 }
439
440 static void rna_MeshColor_color4_set(PointerRNA *ptr, const float *values)
441 {
442         MCol *mcol = (MCol *)ptr->data;
443
444         (&mcol[3].r)[2] = (char)(CLAMPIS(values[0] * 255.0f, 0, 255));
445         (&mcol[3].r)[1] = (char)(CLAMPIS(values[1] * 255.0f, 0, 255));
446         (&mcol[3].r)[0] = (char)(CLAMPIS(values[2] * 255.0f, 0, 255));
447 }
448
449 static void rna_MeshLoopColor_color_get(PointerRNA *ptr, float *values)
450 {
451         MLoopCol *mcol = (MLoopCol *)ptr->data;
452
453         values[0] = (&mcol->r)[0] / 255.0f;
454         values[1] = (&mcol->r)[1] / 255.0f;
455         values[2] = (&mcol->r)[2] / 255.0f;
456 }
457
458 static void rna_MeshLoopColor_color_set(PointerRNA *ptr, const float *values)
459 {
460         MLoopCol *mcol = (MLoopCol *)ptr->data;
461
462         (&mcol->r)[0] = (char)(CLAMPIS(values[0] * 255.0f, 0, 255));
463         (&mcol->r)[1] = (char)(CLAMPIS(values[1] * 255.0f, 0, 255));
464         (&mcol->r)[2] = (char)(CLAMPIS(values[2] * 255.0f, 0, 255));
465 }
466
467 static int rna_Mesh_texspace_editable(PointerRNA *ptr)
468 {
469         Mesh *me = (Mesh *)ptr->data;
470         return (me->texflag & ME_AUTOSPACE) ? 0 : PROP_EDITABLE;
471 }
472
473 static void rna_Mesh_texspace_size_get(PointerRNA *ptr, float values[3])
474 {
475         Mesh *me = (Mesh *)ptr->data;
476
477         if (!me->bb)
478                 BKE_mesh_texspace_calc(me);
479
480         copy_v3_v3(values, me->size);
481 }
482
483 static void rna_Mesh_texspace_loc_get(PointerRNA *ptr, float values[3])
484 {
485         Mesh *me = (Mesh *)ptr->data;
486
487         if (!me->bb)
488                 BKE_mesh_texspace_calc(me);
489
490         copy_v3_v3(values, me->loc);
491 }
492
493 static void rna_MeshVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
494 {
495         Mesh *me = rna_mesh(ptr);
496
497         if (me->dvert) {
498                 MVert *mvert = (MVert *)ptr->data;
499                 MDeformVert *dvert = me->dvert + (mvert - me->mvert);
500
501                 rna_iterator_array_begin(iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
502         }
503         else
504                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
505 }
506
507 static int rna_CustomDataLayer_active_get(PointerRNA *ptr, CustomData *data, int type, int render)
508 {
509         int n = ((CustomDataLayer *)ptr->data) - data->layers;
510
511         if (render) return (n == CustomData_get_render_layer_index(data, type));
512         else return (n == CustomData_get_active_layer_index(data, type));
513 }
514
515 static int rna_CustomDataLayer_clone_get(PointerRNA *ptr, CustomData *data, int type, int render)
516 {
517         int n = ((CustomDataLayer *)ptr->data) - data->layers;
518
519         return (n == CustomData_get_clone_layer_index(data, type));
520 }
521
522 static void rna_CustomDataLayer_active_set(PointerRNA *ptr, CustomData *data, int value, int type, int render)
523 {
524         Mesh *me = ptr->id.data;
525         int n = (((CustomDataLayer *)ptr->data) - data->layers) - CustomData_get_layer_index(data, type);
526
527         if (value == 0)
528                 return;
529
530         if (render) CustomData_set_layer_render(data, type, n);
531         else CustomData_set_layer_active(data, type, n);
532
533         /* sync loop layer */
534         if (type == CD_MTEXPOLY) {
535                 CustomData *ldata = rna_mesh_ldata(ptr);
536                 if (render) CustomData_set_layer_render(ldata, CD_MLOOPUV, n);
537                 else CustomData_set_layer_active(ldata, CD_MLOOPUV, n);
538         }
539
540         mesh_update_customdata_pointers(me, TRUE);
541 }
542
543 static void rna_CustomDataLayer_clone_set(PointerRNA *ptr, CustomData *data, int value, int type, int render)
544 {
545         int n = ((CustomDataLayer *)ptr->data) - data->layers;
546
547         if (value == 0)
548                 return;
549
550         CustomData_set_layer_clone_index(data, type, n);
551 }
552
553 /* uv_layers */
554
555 DEFINE_CUSTOMDATA_LAYER_COLLECTION(uv_layer, ldata, CD_MLOOPUV)
556 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, active, MeshUVLoopLayer)
557 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, clone, MeshUVLoopLayer)
558 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, stencil, MeshUVLoopLayer)
559 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_layer, ldata, CD_MLOOPUV, render, MeshUVLoopLayer)
560
561 /* MeshUVLoopLayer */
562
563 static char *rna_MeshUVLoopLayer_path(PointerRNA * ptr)
564 {
565         return BLI_sprintfN("uv_layers[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
566 }
567
568 static void rna_MeshUVLoopLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
569 {
570         Mesh *me = rna_mesh(ptr);
571         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
572         rna_iterator_array_begin(iter, layer->data, sizeof(MLoopUV), (me->edit_btmesh) ? 0 : me->totloop, 0, NULL);
573 }
574
575 static int rna_MeshUVLoopLayer_data_length(PointerRNA *ptr)
576 {
577         Mesh *me = rna_mesh(ptr);
578         return (me->edit_btmesh) ? 0 : me->totloop;
579 }
580
581 /* face uv_textures */
582
583 DEFINE_CUSTOMDATA_LAYER_COLLECTION(tessface_uv_texture, fdata, CD_MTFACE)
584 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_uv_texture, fdata, CD_MTFACE, active, MeshTextureFaceLayer)
585 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_uv_texture, fdata, CD_MTFACE, clone, MeshTextureFaceLayer)
586 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_uv_texture, fdata, CD_MTFACE, stencil, MeshTextureFaceLayer)
587 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_uv_texture, fdata, CD_MTFACE, render, MeshTextureFaceLayer)
588
589 static void rna_MeshTextureFaceLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
590 {
591         Mesh *me = rna_mesh(ptr);
592         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
593         rna_iterator_array_begin(iter, layer->data, sizeof(MTFace), (me->edit_btmesh) ? 0 : me->totface, 0, NULL);
594 }
595
596 static int rna_MeshTextureFaceLayer_data_length(PointerRNA *ptr)
597 {
598         Mesh *me = rna_mesh(ptr);
599         return (me->edit_btmesh) ? 0 : me->totface;
600 }
601
602 static int rna_MeshTextureFaceLayer_active_render_get(PointerRNA *ptr)
603 {
604         return rna_CustomDataLayer_active_get(ptr, rna_mesh_fdata(ptr), CD_MTFACE, 1);
605 }
606
607 static int rna_MeshTextureFaceLayer_active_get(PointerRNA *ptr)
608 {
609         return rna_CustomDataLayer_active_get(ptr, rna_mesh_fdata(ptr), CD_MTFACE, 0);
610 }
611
612 static int rna_MeshTextureFaceLayer_clone_get(PointerRNA *ptr)
613 {
614         return rna_CustomDataLayer_clone_get(ptr, rna_mesh_fdata(ptr), CD_MTFACE, 0);
615 }
616
617 static void rna_MeshTextureFaceLayer_active_render_set(PointerRNA *ptr, int value)
618 {
619         rna_CustomDataLayer_active_set(ptr, rna_mesh_fdata(ptr), value, CD_MTFACE, 1);
620 }
621
622 static void rna_MeshTextureFaceLayer_active_set(PointerRNA *ptr, int value)
623 {
624         rna_CustomDataLayer_active_set(ptr, rna_mesh_fdata(ptr), value, CD_MTFACE, 0);
625 }
626
627 static void rna_MeshTextureFaceLayer_clone_set(PointerRNA *ptr, int value)
628 {
629         rna_CustomDataLayer_clone_set(ptr, rna_mesh_fdata(ptr), value, CD_MTFACE, 0);
630 }
631
632 static void rna_MeshTextureFaceLayer_name_set(PointerRNA *ptr, const char *value)
633 {
634         CustomData *fdata = rna_mesh_fdata(ptr);
635         CustomDataLayer *cdl = (CustomDataLayer *)ptr->data;
636         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
637         CustomData_set_layer_unique_name(fdata, cdl - fdata->layers);
638 }
639
640 /* poly uv_textures */
641
642 DEFINE_CUSTOMDATA_LAYER_COLLECTION(uv_texture, pdata, CD_MTEXPOLY)
643 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_texture, pdata, CD_MTEXPOLY, active, MeshTexturePolyLayer)
644 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_texture, pdata, CD_MTEXPOLY, clone, MeshTexturePolyLayer)
645 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_texture, pdata, CD_MTEXPOLY, stencil, MeshTexturePolyLayer)
646 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(uv_texture, pdata, CD_MTEXPOLY, render, MeshTexturePolyLayer)
647
648 static void rna_MeshTexturePolyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
649 {
650         Mesh *me = rna_mesh(ptr);
651         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
652         rna_iterator_array_begin(iter, layer->data, sizeof(MTexPoly), (me->edit_btmesh) ? 0 : me->totpoly, 0, NULL);
653 }
654
655 static int rna_MeshTexturePolyLayer_data_length(PointerRNA *ptr)
656 {
657         Mesh *me = rna_mesh(ptr);
658         return (me->edit_btmesh) ? 0 : me->totpoly;
659 }
660
661 static int rna_MeshTexturePolyLayer_active_render_get(PointerRNA *ptr)
662 {
663         return rna_CustomDataLayer_active_get(ptr, rna_mesh_pdata(ptr), CD_MTEXPOLY, 1);
664 }
665
666 static int rna_MeshTexturePolyLayer_active_get(PointerRNA *ptr)
667 {
668         return rna_CustomDataLayer_active_get(ptr, rna_mesh_pdata(ptr), CD_MTEXPOLY, 0);
669 }
670
671 static int rna_MeshTexturePolyLayer_clone_get(PointerRNA *ptr)
672 {
673         return rna_CustomDataLayer_clone_get(ptr, rna_mesh_pdata(ptr), CD_MTEXPOLY, 0);
674 }
675
676 static void rna_MeshTexturePolyLayer_active_render_set(PointerRNA *ptr, int value)
677 {
678         rna_CustomDataLayer_active_set(ptr, rna_mesh_pdata(ptr), value, CD_MTEXPOLY, 1);
679 }
680
681 static void rna_MeshTexturePolyLayer_active_set(PointerRNA *ptr, int value)
682 {
683         rna_CustomDataLayer_active_set(ptr, rna_mesh_pdata(ptr), value, CD_MTEXPOLY, 0);
684 }
685
686 static void rna_MeshTexturePolyLayer_clone_set(PointerRNA *ptr, int value)
687 {
688         rna_CustomDataLayer_clone_set(ptr, rna_mesh_pdata(ptr), value, CD_MTEXPOLY, 0);
689 }
690
691 static void rna_MeshTexturePolyLayer_name_set(PointerRNA *ptr, const char *value)
692 {
693         CustomData *pdata = rna_mesh_pdata(ptr);
694         CustomDataLayer *cdl = (CustomDataLayer *)ptr->data;
695         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
696         CustomData_set_layer_unique_name(pdata, cdl - pdata->layers);
697 }
698
699 /* vertex_color_layers */
700
701 DEFINE_CUSTOMDATA_LAYER_COLLECTION(tessface_vertex_color, fdata, CD_MCOL)
702 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_vertex_color, fdata, CD_MCOL, active, MeshColorLayer)
703 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(tessface_vertex_color, fdata, CD_MCOL, render, MeshColorLayer)
704
705 static void rna_MeshColorLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
706 {
707         Mesh *me = rna_mesh(ptr);
708         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
709         rna_iterator_array_begin(iter, layer->data, sizeof(MCol) * 4, me->totface, 0, NULL);
710 }
711
712 static int rna_MeshColorLayer_data_length(PointerRNA *ptr)
713 {
714         Mesh *me = rna_mesh(ptr);
715         return me->totface;
716 }
717
718 static int rna_MeshColorLayer_active_render_get(PointerRNA *ptr)
719 {
720         return rna_CustomDataLayer_active_get(ptr, rna_mesh_fdata(ptr), CD_MCOL, 1);
721 }
722
723 static int rna_MeshColorLayer_active_get(PointerRNA *ptr)
724 {
725         return rna_CustomDataLayer_active_get(ptr, rna_mesh_fdata(ptr), CD_MCOL, 0);
726 }
727
728 static void rna_MeshColorLayer_active_render_set(PointerRNA *ptr, int value)
729 {
730         rna_CustomDataLayer_active_set(ptr, rna_mesh_fdata(ptr), value, CD_MCOL, 1);
731 }
732
733 static void rna_MeshColorLayer_active_set(PointerRNA *ptr, int value)
734 {
735         rna_CustomDataLayer_active_set(ptr, rna_mesh_fdata(ptr), value, CD_MCOL, 0);
736 }
737
738 DEFINE_CUSTOMDATA_LAYER_COLLECTION(vertex_color, ldata, CD_MLOOPCOL)
739 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(vertex_color, ldata, CD_MLOOPCOL, active, MeshLoopColorLayer)
740 DEFINE_CUSTOMDATA_LAYER_COLLECTION_ACTIVEITEM(vertex_color, ldata, CD_MLOOPCOL, render, MeshLoopColorLayer)
741
742 static void rna_MeshLoopColorLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
743 {
744         Mesh *me = rna_mesh(ptr);
745         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
746         rna_iterator_array_begin(iter, layer->data, sizeof(MLoopCol), me->totloop, 0, NULL);
747 }
748
749 static int rna_MeshLoopColorLayer_data_length(PointerRNA *ptr)
750 {
751         Mesh *me = rna_mesh(ptr);
752         return me->totloop;
753 }
754
755 static int rna_MeshLoopColorLayer_active_render_get(PointerRNA *ptr)
756 {
757         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPCOL, 1);
758 }
759
760 static int rna_MeshLoopColorLayer_active_get(PointerRNA *ptr)
761 {
762         return rna_CustomDataLayer_active_get(ptr, rna_mesh_ldata(ptr), CD_MLOOPCOL, 0);
763 }
764
765 static void rna_MeshLoopColorLayer_active_render_set(PointerRNA *ptr, int value)
766 {
767         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPCOL, 1);
768 }
769
770 static void rna_MeshLoopColorLayer_active_set(PointerRNA *ptr, int value)
771 {
772         rna_CustomDataLayer_active_set(ptr, rna_mesh_ldata(ptr), value, CD_MLOOPCOL, 0);
773 }
774
775 static void rna_MeshLoopColorLayer_name_set(PointerRNA *ptr, const char *value)
776 {
777         /* Mesh *me = rna_mesh(ptr); */ /* UNUSED */
778         /* CustomData *pdata = rna_mesh_pdata(ptr); */ /* UNUSED */
779         CustomDataLayer *cdl = (CustomDataLayer *)ptr->data;
780         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
781         CustomData_set_layer_unique_name(rna_mesh_ldata(ptr), cdl - rna_mesh_ldata(ptr)->layers);
782 }
783
784 static void rna_MeshFloatPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
785 {
786         Mesh *me = rna_mesh(ptr);
787         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
788         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totpoly, 0, NULL);
789 }
790
791 static int rna_MeshFloatPropertyLayer_data_length(PointerRNA *ptr)
792 {
793         Mesh *me = rna_mesh(ptr);
794         return me->totpoly;
795 }
796
797 static int rna_float_layer_check(CollectionPropertyIterator *iter, void *data)
798 {
799         CustomDataLayer *layer = (CustomDataLayer *)data;
800         return (layer->type != CD_PROP_FLT);
801 }
802
803 static void rna_Mesh_polygon_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
804 {
805         CustomData *pdata = rna_mesh_pdata(ptr);
806         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
807                                  rna_float_layer_check);
808 }
809
810 static int rna_Mesh_polygon_float_layers_length(PointerRNA *ptr)
811 {
812         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_FLT);
813 }
814
815 static int rna_int_layer_check(CollectionPropertyIterator *iter, void *data)
816 {
817         CustomDataLayer *layer = (CustomDataLayer *)data;
818         return (layer->type != CD_PROP_INT);
819 }
820
821 static void rna_MeshIntPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
822 {
823         Mesh *me = rna_mesh(ptr);
824         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
825         rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totpoly, 0, NULL);
826 }
827
828 static int rna_MeshIntPropertyLayer_data_length(PointerRNA *ptr)
829 {
830         Mesh *me = rna_mesh(ptr);
831         return me->totpoly;
832 }
833
834 static void rna_Mesh_polygon_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
835 {
836         CustomData *pdata = rna_mesh_pdata(ptr);
837         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
838                                  rna_int_layer_check);
839 }
840
841 static int rna_Mesh_polygon_int_layers_length(PointerRNA *ptr)
842 {
843         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_INT);
844 }
845
846 static int rna_string_layer_check(CollectionPropertyIterator *iter, void *data)
847 {
848         CustomDataLayer *layer = (CustomDataLayer *)data;
849         return (layer->type != CD_PROP_STR);
850 }
851
852 static void rna_MeshStringPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
853 {
854         Mesh *me = rna_mesh(ptr);
855         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
856         rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totpoly, 0, NULL);
857 }
858
859 static int rna_MeshStringPropertyLayer_data_length(PointerRNA *ptr)
860 {
861         Mesh *me = rna_mesh(ptr);
862         return me->totpoly;
863 }
864
865 static void rna_Mesh_polygon_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
866 {
867         CustomData *pdata = rna_mesh_pdata(ptr);
868         rna_iterator_array_begin(iter, (void *)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
869                                  rna_string_layer_check);
870 }
871
872 static int rna_Mesh_polygon_string_layers_length(PointerRNA *ptr)
873 {
874         return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_STR);
875 }
876
877 /* Skin vertices */
878 DEFINE_CUSTOMDATA_LAYER_COLLECTION(skin_vertice, vdata, CD_MVERT_SKIN);
879
880 static char *rna_MeshSkinVertexLayer_path(PointerRNA *ptr)
881 {
882         return BLI_sprintfN("skin_vertices[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
883 }
884
885 static char *rna_VertCustomData_data_path(PointerRNA *ptr, char *collection, int type);
886 static char *rna_MeshSkinVertex_path(PointerRNA *ptr)
887 {
888         return rna_VertCustomData_data_path(ptr, "skin_vertices", CD_MVERT_SKIN);
889 }
890
891 static void rna_MeshSkinVertexLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
892 {
893         Mesh *me = rna_mesh(ptr);
894         CustomDataLayer *layer = (CustomDataLayer *)ptr->data;
895         rna_iterator_array_begin(iter, layer->data, sizeof(MVertSkin), me->totvert, 0, NULL);
896 }
897
898 static int rna_MeshSkinVertexLayer_data_length(PointerRNA *ptr)
899 {
900         Mesh *me = rna_mesh(ptr);
901         return me->totvert;
902 }
903
904 static void rna_MeshSkinVertexLayer_name_set(PointerRNA *ptr, const char *value)
905 {
906         CustomDataLayer *cdl = (CustomDataLayer *)ptr->data;
907         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
908         CustomData_set_layer_unique_name(rna_mesh_vdata(ptr), cdl - rna_mesh_vdata(ptr)->layers);
909 }
910
911 /* End skin vertices */
912
913 static void rna_TexturePoly_image_set(PointerRNA *ptr, PointerRNA value)
914 {
915         MTexPoly *tf = (MTexPoly *)ptr->data;
916         ID *id = value.data;
917
918         if (id) {
919                 /* special exception here, individual faces don't count
920                  * as reference, but we do ensure the refcount is not zero */
921                 if (id->us == 0)
922                         id_us_plus(id);
923                 else
924                         id_lib_extern(id);
925         }
926
927         tf->tpage = (struct Image *)id;
928 }
929
930 /* while this is supposed to be readonly,
931  * keep it to support importers that only make tessfaces */
932 static void rna_TextureFace_image_set(PointerRNA *ptr, PointerRNA value)
933 {
934         MTFace *tf = (MTFace *)ptr->data;
935         ID *id = value.data;
936
937         if (id) {
938                 /* special exception here, individual faces don't count
939                  * as reference, but we do ensure the refcount is not zero */
940                 if (id->us == 0)
941                         id_us_plus(id);
942                 else
943                         id_lib_extern(id);
944         }
945
946         tf->tpage = (struct Image *)id;
947 }
948
949 static void rna_Mesh_auto_smooth_angle_set(PointerRNA *ptr, float value)
950 {
951         Mesh *me = rna_mesh(ptr);
952         value = RAD2DEGF(value);
953         CLAMP(value, 1.0f, 80.0f);
954         me->smoothresh = (int)value;
955 }
956
957 static float rna_Mesh_auto_smooth_angle_get(PointerRNA *ptr)
958 {
959         Mesh *me = rna_mesh(ptr);
960         return DEG2RADF((float)me->smoothresh);
961 }
962
963 static int rna_MeshTessFace_verts_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
964 {
965         MFace *face = (MFace *)ptr->data;
966
967         if (face)
968                 length[0] = (face->v4) ? 4 : 3;
969         else
970                 length[0] = 4;  /* XXX rna_raw_access wants the length of a dummy face. this needs fixing. - Campbell */
971
972         return length[0];
973 }
974
975 static void rna_MeshTessFace_verts_get(PointerRNA *ptr, int *values)
976 {
977         MFace *face = (MFace *)ptr->data;
978         memcpy(values, &face->v1, (face->v4 ? 4 : 3) * sizeof(int));
979 }
980
981 static void rna_MeshTessFace_verts_set(PointerRNA *ptr, const int *values)
982 {
983         MFace *face = (MFace *)ptr->data;
984         memcpy(&face->v1, values, (face->v4 ? 4 : 3) * sizeof(int));
985 }
986
987 /* poly.vertices - this is faked loop access for convenience */
988 static int rna_MeshPoly_vertices_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
989 {
990         MPoly *mp = (MPoly *)ptr->data;
991         /* note, raw access uses dummy item, this _could_ crash, watch out for this, mface uses it but it cant work here */
992         return (length[0] = mp->totloop);
993 }
994
995 static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
996 {
997         Mesh *me = rna_mesh(ptr);
998         MPoly *mp = (MPoly *)ptr->data;
999         MLoop *ml = &me->mloop[mp->loopstart];
1000         unsigned int i;
1001         for (i = mp->totloop; i > 0; i--, values++, ml++) {
1002                 *values = ml->v;
1003         }
1004 }
1005
1006 static void rna_MeshPoly_vertices_set(PointerRNA *ptr, const int *values)
1007 {
1008         Mesh *me = rna_mesh(ptr);
1009         MPoly *mp = (MPoly *)ptr->data;
1010         MLoop *ml = &me->mloop[mp->loopstart];
1011         unsigned int i;
1012         for (i = mp->totloop; i > 0; i--, values++, ml++) {
1013                 ml->v = *values;
1014         }
1015 }
1016
1017 static void rna_MeshPoly_material_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
1018 {
1019         Mesh *me = rna_mesh(ptr);
1020         *min = 0;
1021         *max = max_ii(0, me->totcol - 1);
1022 }
1023
1024 static int rna_MeshVertex_index_get(PointerRNA *ptr)
1025 {
1026         Mesh *me = rna_mesh(ptr);
1027         MVert *vert = (MVert *)ptr->data;
1028         return (int)(vert - me->mvert);
1029 }
1030
1031 static int rna_MeshEdge_index_get(PointerRNA *ptr)
1032 {
1033         Mesh *me = rna_mesh(ptr);
1034         MEdge *edge = (MEdge *)ptr->data;
1035         return (int)(edge - me->medge);
1036 }
1037
1038 static int rna_MeshTessFace_index_get(PointerRNA *ptr)
1039 {
1040         Mesh *me = rna_mesh(ptr);
1041         MFace *face = (MFace *)ptr->data;
1042         return (int)(face - me->mface);
1043 }
1044
1045 static int rna_MeshPolygon_index_get(PointerRNA *ptr)
1046 {
1047         Mesh *me = rna_mesh(ptr);
1048         MPoly *mpoly = (MPoly *)ptr->data;
1049         return (int)(mpoly - me->mpoly);
1050 }
1051
1052 static int rna_MeshLoop_index_get(PointerRNA *ptr)
1053 {
1054         Mesh *me = rna_mesh(ptr);
1055         MLoop *mloop = (MLoop *)ptr->data;
1056         return (int)(mloop - me->mloop);
1057 }
1058
1059 /* path construction */
1060
1061 static char *rna_VertexGroupElement_path(PointerRNA *ptr)
1062 {
1063         Mesh *me = rna_mesh(ptr); /* XXX not always! */
1064         MDeformWeight *dw = (MDeformWeight *)ptr->data;
1065         MDeformVert *dvert;
1066         int a, b;
1067
1068         for (a = 0, dvert = me->dvert; a < me->totvert; a++, dvert++)
1069                 for (b = 0; b < dvert->totweight; b++)
1070                         if (dw == &dvert->dw[b])
1071                                 return BLI_sprintfN("vertices[%d].groups[%d]", a, b);
1072
1073         return NULL;
1074 }
1075
1076 static char *rna_MeshPolygon_path(PointerRNA *ptr)
1077 {
1078         return BLI_sprintfN("polygons[%d]", (int)((MPoly *)ptr->data - rna_mesh(ptr)->mpoly));
1079 }
1080
1081 static char *rna_MeshTessFace_path(PointerRNA *ptr)
1082 {
1083         return BLI_sprintfN("tessfaces[%d]", (int)((MFace *)ptr->data - rna_mesh(ptr)->mface));
1084 }
1085
1086 static char *rna_MeshEdge_path(PointerRNA *ptr)
1087 {
1088         return BLI_sprintfN("edges[%d]", (int)((MEdge *)ptr->data - rna_mesh(ptr)->medge));
1089 }
1090
1091 static char *rna_MeshLoop_path(PointerRNA *ptr)
1092 {
1093         return BLI_sprintfN("loops[%d]", (int)((MLoop *)ptr->data - rna_mesh(ptr)->mloop));
1094 }
1095
1096
1097 static char *rna_MeshVertex_path(PointerRNA *ptr)
1098 {
1099         return BLI_sprintfN("vertices[%d]", (int)((MVert *)ptr->data - rna_mesh(ptr)->mvert));
1100 }
1101
1102 static char *rna_MeshTextureFaceLayer_path(PointerRNA *ptr)
1103 {
1104         return BLI_sprintfN("tessface_uv_textures[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1105 }
1106
1107 static char *rna_MeshTexturePolyLayer_path(PointerRNA *ptr)
1108 {
1109         return BLI_sprintfN("uv_textures[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1110 }
1111
1112 static char *rna_VertCustomData_data_path(PointerRNA *ptr, char *collection, int type)
1113 {
1114         CustomDataLayer *cdl;
1115         Mesh *me = rna_mesh(ptr);
1116         CustomData *vdata = rna_mesh_vdata(ptr);
1117         int a, b, totvert = (me->edit_btmesh) ? 0 : me->totvert;
1118
1119         for (cdl = vdata->layers, a = 0; a < vdata->totlayer; cdl++, a++) {
1120                 if (cdl->type == type) {
1121                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1122                         if (b >= 0 && b < totvert)
1123                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
1124                 }
1125         }
1126
1127         return NULL;
1128 }
1129
1130 static char *rna_PolyCustomData_data_path(PointerRNA *ptr, char *collection, int type)
1131 {
1132         CustomDataLayer *cdl;
1133         Mesh *me = rna_mesh(ptr);
1134         CustomData *pdata = rna_mesh_pdata(ptr);
1135         int a, b, totpoly = (me->edit_btmesh) ? 0 : me->totpoly;
1136
1137         for (cdl = pdata->layers, a = 0; a < pdata->totlayer; cdl++, a++) {
1138                 if (cdl->type == type) {
1139                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1140                         if (b >= 0 && b < totpoly)
1141                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
1142                 }
1143         }
1144
1145         return NULL;
1146 }
1147
1148 static char *rna_LoopCustomData_data_path(PointerRNA *ptr, char *collection, int type)
1149 {
1150         CustomDataLayer *cdl;
1151         Mesh *me = rna_mesh(ptr);
1152         CustomData *ldata = rna_mesh_ldata(ptr);
1153         int a, b, totloop = (me->edit_btmesh) ? 0 : me->totloop;
1154
1155         for (cdl = ldata->layers, a = 0; a < ldata->totlayer; cdl++, a++) {
1156                 if (cdl->type == type) {
1157                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1158                         if (b >= 0 && b < totloop)
1159                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
1160                 }
1161         }
1162
1163         return NULL;
1164 }
1165
1166 static char *rna_FaceCustomData_data_path(PointerRNA *ptr, char *collection, int type)
1167 {
1168         CustomDataLayer *cdl;
1169         Mesh *me = rna_mesh(ptr);
1170         CustomData *fdata = rna_mesh_fdata(ptr);
1171         int a, b, totloop = (me->edit_btmesh) ? 0 : me->totloop;
1172
1173         for (cdl = fdata->layers, a = 0; a < fdata->totlayer; cdl++, a++) {
1174                 if (cdl->type == type) {
1175                         b = ((char *)ptr->data - ((char *)cdl->data)) / CustomData_sizeof(type);
1176                         if (b >= 0 && b < totloop)
1177                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
1178                 }
1179         }
1180
1181         return NULL;
1182 }
1183
1184 static char *rna_MeshUVLoop_path(PointerRNA *ptr)
1185 {
1186         return rna_LoopCustomData_data_path(ptr, "uv_layers", CD_MLOOPUV);
1187 }
1188
1189 static char *rna_MeshTextureFace_path(PointerRNA *ptr)
1190 {
1191         return rna_FaceCustomData_data_path(ptr, "tessface_uv_textures", CD_MTFACE);
1192 }
1193
1194 static char *rna_MeshTexturePoly_path(PointerRNA *ptr)
1195 {
1196         return rna_PolyCustomData_data_path(ptr, "uv_textures", CD_MTEXPOLY);
1197 }
1198
1199 static char *rna_MeshColorLayer_path(PointerRNA *ptr)
1200 {
1201         return BLI_sprintfN("tessface_vertex_colors[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1202 }
1203
1204 static char *rna_MeshLoopColorLayer_path(PointerRNA *ptr)
1205 {
1206         return BLI_sprintfN("vertex_colors[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1207 }
1208
1209 static char *rna_MeshColor_path(PointerRNA *ptr)
1210 {
1211         return rna_LoopCustomData_data_path(ptr, "vertex_colors", CD_MLOOPCOL);
1212 }
1213
1214 static char *rna_MeshIntPropertyLayer_path(PointerRNA *ptr)
1215 {
1216         return BLI_sprintfN("int_layers[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1217 }
1218
1219 static char *rna_MeshIntProperty_path(PointerRNA *ptr)
1220 {
1221         return rna_PolyCustomData_data_path(ptr, "layers_int", CD_PROP_INT);
1222 }
1223
1224 static char *rna_MeshFloatPropertyLayer_path(PointerRNA *ptr)
1225 {
1226         return BLI_sprintfN("float_layers[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1227 }
1228
1229 static char *rna_MeshFloatProperty_path(PointerRNA *ptr)
1230 {
1231         return rna_PolyCustomData_data_path(ptr, "layers_float", CD_PROP_FLT);
1232 }
1233
1234 static char *rna_MeshStringPropertyLayer_path(PointerRNA *ptr)
1235 {
1236         return BLI_sprintfN("string_layers[\"%s\"]", ((CustomDataLayer *)ptr->data)->name);
1237 }
1238
1239 static char *rna_MeshStringProperty_path(PointerRNA *ptr)
1240 {
1241         return rna_PolyCustomData_data_path(ptr, "layers_string", CD_PROP_STR);
1242 }
1243
1244 static int rna_Mesh_tot_vert_get(PointerRNA *ptr)
1245 {
1246         Mesh *me = rna_mesh(ptr);
1247         return me->edit_btmesh ? me->edit_btmesh->bm->totvertsel : 0;
1248 }
1249 static int rna_Mesh_tot_edge_get(PointerRNA *ptr)
1250 {
1251         Mesh *me = rna_mesh(ptr);
1252         return me->edit_btmesh ? me->edit_btmesh->bm->totedgesel : 0;
1253 }
1254 static int rna_Mesh_tot_face_get(PointerRNA *ptr)
1255 {
1256         Mesh *me = rna_mesh(ptr);
1257         return me->edit_btmesh ? me->edit_btmesh->bm->totfacesel : 0;
1258 }
1259
1260 static PointerRNA rna_Mesh_vertex_color_new(struct Mesh *me, struct bContext *C, const char *name)
1261 {
1262         PointerRNA ptr;
1263         CustomData *ldata;
1264         CustomDataLayer *cdl = NULL;
1265         int index = ED_mesh_color_add(C, NULL, NULL, me, name, FALSE);
1266
1267         if (index != -1) {
1268                 ldata = rna_mesh_ldata_helper(me);
1269                 cdl = &ldata->layers[CustomData_get_layer_index_n(ldata, CD_MLOOPCOL, index)];
1270         }
1271
1272         RNA_pointer_create(&me->id, &RNA_MeshLoopColorLayer, cdl, &ptr);
1273         return ptr;
1274 }
1275
1276 static PointerRNA rna_Mesh_tessface_vertex_color_new(struct Mesh *me, struct bContext *C, ReportList *reports,
1277                                                      const char *name)
1278 {
1279         PointerRNA ptr;
1280         CustomData *fdata;
1281         CustomDataLayer *cdl = NULL;
1282         int index;
1283
1284         if (me->edit_btmesh) {
1285                 BKE_report(reports, RPT_ERROR, "Cannot add tessface colors in edit mode");
1286                 return PointerRNA_NULL;
1287         }
1288
1289         if (me->mpoly) {
1290                 BKE_report(reports, RPT_ERROR, "Cannot add tessface colors when MPoly's exist");
1291                 return PointerRNA_NULL;
1292         }
1293
1294         index = ED_mesh_color_add(C, NULL, NULL, me, name, FALSE);
1295
1296         if (index != -1) {
1297                 fdata = rna_mesh_fdata_helper(me);
1298                 cdl = &fdata->layers[CustomData_get_layer_index_n(fdata, CD_MCOL, index)];
1299         }
1300
1301         RNA_pointer_create(&me->id, &RNA_MeshColorLayer, cdl, &ptr);
1302         return ptr;
1303 }
1304
1305 static PointerRNA rna_Mesh_polygon_int_property_new(struct Mesh *me, struct bContext *C, const char *name)
1306 {
1307         PointerRNA ptr;
1308         CustomDataLayer *cdl = NULL;
1309         int index;
1310
1311         CustomData_add_layer_named(&me->pdata, CD_PROP_INT, CD_DEFAULT, NULL, me->totpoly, name);
1312         index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_INT, name);
1313
1314         cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
1315
1316         RNA_pointer_create(&me->id, &RNA_MeshIntPropertyLayer, cdl, &ptr);
1317         return ptr;
1318 }
1319
1320 static PointerRNA rna_Mesh_polygon_float_property_new(struct Mesh *me, struct bContext *C, const char *name)
1321 {
1322         PointerRNA ptr;
1323         CustomDataLayer *cdl = NULL;
1324         int index;
1325
1326         CustomData_add_layer_named(&me->pdata, CD_PROP_FLT, CD_DEFAULT, NULL, me->totpoly, name);
1327         index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_FLT, name);
1328
1329         cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
1330
1331         RNA_pointer_create(&me->id, &RNA_MeshFloatPropertyLayer, cdl, &ptr);
1332         return ptr;
1333 }
1334
1335 static PointerRNA rna_Mesh_polygon_string_property_new(struct Mesh *me, struct bContext *C, const char *name)
1336 {
1337         PointerRNA ptr;
1338         CustomDataLayer *cdl = NULL;
1339         int index;
1340
1341         CustomData_add_layer_named(&me->pdata, CD_PROP_STR, CD_DEFAULT, NULL, me->totpoly, name);
1342         index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_STR, name);
1343
1344         cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
1345
1346         RNA_pointer_create(&me->id, &RNA_MeshStringPropertyLayer, cdl, &ptr);
1347         return ptr;
1348 }
1349
1350 static PointerRNA rna_Mesh_uv_texture_new(struct Mesh *me, struct bContext *C, const char *name)
1351 {
1352         PointerRNA ptr;
1353         CustomData *pdata;
1354         CustomDataLayer *cdl = NULL;
1355         int index = ED_mesh_uv_texture_add(C, me, name, FALSE);
1356
1357         if (index != -1) {
1358                 pdata = rna_mesh_pdata_helper(me);
1359                 cdl = &pdata->layers[CustomData_get_layer_index_n(pdata, CD_MTEXPOLY, index)];
1360         }
1361
1362         RNA_pointer_create(&me->id, &RNA_MeshTexturePolyLayer, cdl, &ptr);
1363         return ptr;
1364 }
1365
1366 /* while this is supposed to be readonly,
1367  * keep it to support importers that only make tessfaces */
1368
1369 static PointerRNA rna_Mesh_tessface_uv_texture_new(struct Mesh *me, struct bContext *C, ReportList *reports,
1370                                                    const char *name)
1371 {
1372         PointerRNA ptr;
1373         CustomData *fdata;
1374         CustomDataLayer *cdl = NULL;
1375         int index;
1376
1377         if (me->edit_btmesh) {
1378                 BKE_report(reports, RPT_ERROR, "Cannot add tessface uv's in edit mode");
1379                 return PointerRNA_NULL;
1380         }
1381
1382         if (me->mpoly) {
1383                 BKE_report(reports, RPT_ERROR, "Cannot add tessface uv's when MPoly's exist");
1384                 return PointerRNA_NULL;
1385         }
1386
1387         index = ED_mesh_uv_texture_add(C, me, name, FALSE);
1388
1389         if (index != -1) {
1390                 fdata = rna_mesh_fdata_helper(me);
1391                 cdl = &fdata->layers[CustomData_get_layer_index_n(fdata, CD_MTFACE, index)];
1392         }
1393
1394         RNA_pointer_create(&me->id, &RNA_MeshTextureFaceLayer, cdl, &ptr);
1395         return ptr;
1396 }
1397
1398 /* only to quiet warnings */
1399 static void UNUSED_FUNCTION(rna_mesh_unused)(void)
1400 {
1401         /* unused functions made by macros */
1402         (void)rna_Mesh_skin_vertice_index_range;
1403         (void)rna_Mesh_tessface_uv_texture_active_set;
1404         (void)rna_Mesh_tessface_uv_texture_clone_get;
1405         (void)rna_Mesh_tessface_uv_texture_clone_index_get;
1406         (void)rna_Mesh_tessface_uv_texture_clone_index_set;
1407         (void)rna_Mesh_tessface_uv_texture_clone_set;
1408         (void)rna_Mesh_tessface_uv_texture_index_range;
1409         (void)rna_Mesh_tessface_uv_texture_render_get;
1410         (void)rna_Mesh_tessface_uv_texture_render_index_get;
1411         (void)rna_Mesh_tessface_uv_texture_render_index_set;
1412         (void)rna_Mesh_tessface_uv_texture_render_set;
1413         (void)rna_Mesh_tessface_uv_texture_stencil_get;
1414         (void)rna_Mesh_tessface_uv_texture_stencil_index_get;
1415         (void)rna_Mesh_tessface_uv_texture_stencil_index_set;
1416         (void)rna_Mesh_tessface_uv_texture_stencil_set;
1417         (void)rna_Mesh_tessface_vertex_color_active_set;
1418         (void)rna_Mesh_tessface_vertex_color_index_range;
1419         (void)rna_Mesh_tessface_vertex_color_render_get;
1420         (void)rna_Mesh_tessface_vertex_color_render_index_get;
1421         (void)rna_Mesh_tessface_vertex_color_render_index_set;
1422         (void)rna_Mesh_tessface_vertex_color_render_set;
1423         (void)rna_Mesh_uv_layer_render_get;
1424         (void)rna_Mesh_uv_layer_render_index_get;
1425         (void)rna_Mesh_uv_layer_render_index_set;
1426         (void)rna_Mesh_uv_layer_render_set;
1427         (void)rna_Mesh_uv_texture_render_get;
1428         (void)rna_Mesh_uv_texture_render_index_get;
1429         (void)rna_Mesh_uv_texture_render_index_set;
1430         (void)rna_Mesh_uv_texture_render_set;
1431         (void)rna_Mesh_vertex_color_render_get;
1432         (void)rna_Mesh_vertex_color_render_index_get;
1433         (void)rna_Mesh_vertex_color_render_index_set;
1434         (void)rna_Mesh_vertex_color_render_set;
1435         /* end unused function block */
1436 }
1437
1438 #else
1439
1440 static void rna_def_mvert_group(BlenderRNA *brna)
1441 {
1442         StructRNA *srna;
1443         PropertyRNA *prop;
1444
1445         srna = RNA_def_struct(brna, "VertexGroupElement", NULL);
1446         RNA_def_struct_sdna(srna, "MDeformWeight");
1447         RNA_def_struct_path_func(srna, "rna_VertexGroupElement_path");
1448         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
1449         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
1450
1451         /* we can't point to actual group, it is in the object and so
1452          * there is no unique group to point to, hence the index */
1453         prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
1454         RNA_def_property_int_sdna(prop, NULL, "def_nr");
1455         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1456         RNA_def_property_ui_text(prop, "Group Index", "");
1457         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1458
1459         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
1460         RNA_def_property_range(prop, 0.0f, 1.0f);
1461         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
1462         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1463 }
1464
1465 static void rna_def_mvert(BlenderRNA *brna)
1466 {
1467         StructRNA *srna;
1468         PropertyRNA *prop;
1469
1470         srna = RNA_def_struct(brna, "MeshVertex", NULL);
1471         RNA_def_struct_sdna(srna, "MVert");
1472         RNA_def_struct_ui_text(srna, "Mesh Vertex", "Vertex in a Mesh datablock");
1473         RNA_def_struct_path_func(srna, "rna_MeshVertex_path");
1474         RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
1475
1476         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1477         RNA_def_property_ui_text(prop, "Location", "");
1478         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1479
1480         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1481         /* RNA_def_property_float_sdna(prop, NULL, "no"); */
1482         RNA_def_property_array(prop, 3);
1483         RNA_def_property_range(prop, -1.0f, 1.0f);
1484         RNA_def_property_float_funcs(prop, "rna_MeshVertex_normal_get", "rna_MeshVertex_normal_set", NULL);
1485         RNA_def_property_ui_text(prop, "Normal", "Vertex Normal");
1486
1487         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1488         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1489         RNA_def_property_ui_text(prop, "Select", "");
1490         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1491
1492         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1493         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1494         RNA_def_property_ui_text(prop, "Hide", "");
1495         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1496
1497         prop = RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1498         RNA_def_property_float_funcs(prop, "rna_MeshVertex_bevel_weight_get", "rna_MeshVertex_bevel_weight_set", NULL);
1499         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier 'Only Vertices' option");
1500         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1501
1502         prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
1503         RNA_def_property_collection_funcs(prop, "rna_MeshVertex_groups_begin", "rna_iterator_array_next",
1504                                           "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1505         RNA_def_property_struct_type(prop, "VertexGroupElement");
1506         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");
1507
1508         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1509         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1510         RNA_def_property_int_funcs(prop, "rna_MeshVertex_index_get", NULL, NULL);
1511         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1512 }
1513
1514 static void rna_def_medge(BlenderRNA *brna)
1515 {
1516         StructRNA *srna;
1517         PropertyRNA *prop;
1518
1519         srna = RNA_def_struct(brna, "MeshEdge", NULL);
1520         RNA_def_struct_sdna(srna, "MEdge");
1521         RNA_def_struct_ui_text(srna, "Mesh Edge", "Edge in a Mesh datablock");
1522         RNA_def_struct_path_func(srna, "rna_MeshEdge_path");
1523         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1524
1525         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1526         RNA_def_property_int_sdna(prop, NULL, "v1");
1527         RNA_def_property_array(prop, 2);
1528         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1529         /* XXX allows creating invalid meshes */
1530
1531         prop = RNA_def_property(srna, "crease", PROP_FLOAT, PROP_NONE);
1532         RNA_def_property_float_funcs(prop, "rna_MEdge_crease_get", "rna_MEdge_crease_set", NULL);
1533         RNA_def_property_ui_text(prop, "Crease", "Weight used by the Subsurf modifier for creasing");
1534         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1535
1536         prop = RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1537         RNA_def_property_float_funcs(prop, "rna_MEdge_bevel_weight_get", "rna_MEdge_bevel_weight_set", NULL);
1538         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier");
1539         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1540
1541         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1542         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1543         RNA_def_property_ui_text(prop, "Select", "");
1544         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1545
1546         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1547         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1548         RNA_def_property_ui_text(prop, "Hide", "");
1549         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1550
1551         prop = RNA_def_property(srna, "use_seam", PROP_BOOLEAN, PROP_NONE);
1552         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SEAM);
1553         RNA_def_property_ui_text(prop, "Seam", "Seam edge for UV unwrapping");
1554         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1555
1556         prop = RNA_def_property(srna, "use_edge_sharp", PROP_BOOLEAN, PROP_NONE);
1557         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SHARP);
1558         RNA_def_property_ui_text(prop, "Sharp", "Sharp edge for the EdgeSplit modifier");
1559         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1560
1561         prop = RNA_def_property(srna, "is_loose", PROP_BOOLEAN, PROP_NONE);
1562         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_LOOSEEDGE);
1563         RNA_def_property_ui_text(prop, "Loose", "Loose edge");
1564
1565         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1566         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1567         RNA_def_property_int_funcs(prop, "rna_MeshEdge_index_get", NULL, NULL);
1568         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1569 }
1570
1571 static void rna_def_mface(BlenderRNA *brna)
1572 {
1573         StructRNA *srna;
1574         PropertyRNA *prop;
1575
1576         srna = RNA_def_struct(brna, "MeshTessFace", NULL);
1577         RNA_def_struct_sdna(srna, "MFace");
1578         RNA_def_struct_ui_text(srna, "Mesh TessFace", "TessFace in a Mesh datablock");
1579         RNA_def_struct_path_func(srna, "rna_MeshTessFace_path");
1580         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1581
1582         /* XXX allows creating invalid meshes */
1583         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1584         RNA_def_property_array(prop, 4);
1585         RNA_def_property_flag(prop, PROP_DYNAMIC);
1586         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshTessFace_verts_get_length");
1587         RNA_def_property_int_funcs(prop, "rna_MeshTessFace_verts_get", "rna_MeshTessFace_verts_set", NULL);
1588         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1589
1590         /* leaving this fixed size array for foreach_set used in import scripts */
1591         prop = RNA_def_property(srna, "vertices_raw", PROP_INT, PROP_UNSIGNED);
1592         RNA_def_property_int_sdna(prop, NULL, "v1");
1593         RNA_def_property_array(prop, 4);
1594         RNA_def_property_ui_text(prop, "Vertices", "Fixed size vertex indices array");
1595
1596         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1597         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1598         RNA_def_property_ui_text(prop, "Material Index", "");
1599         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshPoly_material_index_range"); /* reuse for tessface is ok */
1600         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1601
1602         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1603         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1604         RNA_def_property_ui_text(prop, "Select", "");
1605         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1606
1607         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1608         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1609         RNA_def_property_ui_text(prop, "Hide", "");
1610         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1611
1612         prop = RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1613         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1614         RNA_def_property_ui_text(prop, "Smooth", "");
1615         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1616
1617         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1618         RNA_def_property_array(prop, 3);
1619         RNA_def_property_range(prop, -1.0f, 1.0f);
1620         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1621         RNA_def_property_float_funcs(prop, "rna_MeshTessFace_normal_get", NULL, NULL);
1622         RNA_def_property_ui_text(prop, "Face normal", "Local space unit length normal vector for this face");
1623
1624         prop = RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1625         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1626         RNA_def_property_float_funcs(prop, "rna_MeshTessFace_area_get", NULL, NULL);
1627         RNA_def_property_ui_text(prop, "Face area", "Read only area of the face");
1628
1629         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1630         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1631         RNA_def_property_int_funcs(prop, "rna_MeshTessFace_index_get", NULL, NULL);
1632         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1633 }
1634
1635
1636 static void rna_def_mloop(BlenderRNA *brna)
1637 {
1638         StructRNA *srna;
1639         PropertyRNA *prop;
1640
1641         srna = RNA_def_struct(brna, "MeshLoop", NULL);
1642         RNA_def_struct_sdna(srna, "MLoop");
1643         RNA_def_struct_ui_text(srna, "Mesh Loop", "Loop in a Mesh datablock");
1644         RNA_def_struct_path_func(srna, "rna_MeshLoop_path");
1645         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1646
1647         prop = RNA_def_property(srna, "vertex_index", PROP_INT, PROP_UNSIGNED);
1648         RNA_def_property_int_sdna(prop, NULL, "v");
1649         RNA_def_property_ui_text(prop, "Vertex", "Vertex index");
1650
1651         prop = RNA_def_property(srna, "edge_index", PROP_INT, PROP_UNSIGNED);
1652         RNA_def_property_int_sdna(prop, NULL, "e");
1653         RNA_def_property_ui_text(prop, "Edge", "Edge index");
1654
1655         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1656         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1657         RNA_def_property_int_funcs(prop, "rna_MeshLoop_index_get", NULL, NULL);
1658         RNA_def_property_ui_text(prop, "Index", "Index number of the loop");
1659 }
1660
1661 static void rna_def_mpolygon(BlenderRNA *brna)
1662 {
1663         StructRNA *srna;
1664         PropertyRNA *prop;
1665
1666         srna = RNA_def_struct(brna, "MeshPolygon", NULL);
1667         RNA_def_struct_sdna(srna, "MPoly");
1668         RNA_def_struct_ui_text(srna, "Mesh Polygon", "Polygon in a Mesh datablock");
1669         RNA_def_struct_path_func(srna, "rna_MeshPolygon_path");
1670         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1671
1672         /* Faked, actually access to loop vertex values, don't this way because manually setting up
1673          * vertex/edge per loop is very low level.
1674          * Instead we setup poly sizes, assign indices, then calc edges automatic when creating
1675          * meshes from rna/py. */
1676         prop = RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1677         /* Eek, this is still used in some cases but in fact we don't want to use it at all here. */
1678         RNA_def_property_array(prop, 3);
1679         RNA_def_property_flag(prop, PROP_DYNAMIC);
1680         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshPoly_vertices_get_length");
1681         RNA_def_property_int_funcs(prop, "rna_MeshPoly_vertices_get", "rna_MeshPoly_vertices_set", NULL);
1682         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1683
1684         /* these are both very low level access */
1685         prop = RNA_def_property(srna, "loop_start", PROP_INT, PROP_UNSIGNED);
1686         RNA_def_property_int_sdna(prop, NULL, "loopstart");
1687         RNA_def_property_ui_text(prop, "Loop Start", "");
1688         /* also low level */
1689         prop = RNA_def_property(srna, "loop_total", PROP_INT, PROP_UNSIGNED);
1690         RNA_def_property_int_sdna(prop, NULL, "totloop");
1691         RNA_def_property_ui_text(prop, "Loop Total", "");
1692
1693         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1694         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1695         RNA_def_property_ui_text(prop, "Material Index", "");
1696         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshPoly_material_index_range");
1697         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1698
1699         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1700         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1701         RNA_def_property_ui_text(prop, "Select", "");
1702         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1703
1704         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1705         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1706         RNA_def_property_ui_text(prop, "Hide", "");
1707         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1708
1709         prop = RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1710         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1711         RNA_def_property_ui_text(prop, "Smooth", "");
1712         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1713
1714         prop = RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1715         RNA_def_property_array(prop, 3);
1716         RNA_def_property_range(prop, -1.0f, 1.0f);
1717         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1718         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_normal_get", NULL, NULL);
1719         RNA_def_property_ui_text(prop, "Face normal", "Local space unit length normal vector for this polygon");
1720
1721         prop = RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1722         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1723         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_area_get", NULL, NULL);
1724         RNA_def_property_ui_text(prop, "Face area", "Read only area of the face");
1725
1726         prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1727         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1728         RNA_def_property_int_funcs(prop, "rna_MeshPolygon_index_get", NULL, NULL);
1729         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1730 }
1731
1732 /* mesh.loop_uvs */
1733 static void rna_def_mloopuv(BlenderRNA *brna)
1734 {
1735         StructRNA *srna;
1736         PropertyRNA *prop;
1737
1738         srna = RNA_def_struct(brna, "MeshUVLoopLayer", NULL);
1739         RNA_def_struct_sdna(srna, "CustomDataLayer");
1740         RNA_def_struct_path_func(srna, "rna_MeshUVLoopLayer_path");
1741
1742         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1743         RNA_def_property_struct_type(prop, "MeshUVLoop");
1744         RNA_def_property_collection_funcs(prop, "rna_MeshUVLoopLayer_data_begin", "rna_iterator_array_next",
1745                                           "rna_iterator_array_end", "rna_iterator_array_get",
1746                                           "rna_MeshUVLoopLayer_data_length", NULL, NULL, NULL);
1747
1748         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1749         RNA_def_struct_name_property(srna, prop);
1750         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1751         RNA_def_property_ui_text(prop, "Name", "Name of UV map");
1752         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1753
1754         srna = RNA_def_struct(brna, "MeshUVLoop", NULL);
1755         RNA_def_struct_sdna(srna, "MLoopUV");
1756         RNA_def_struct_path_func(srna, "rna_MeshUVLoop_path");
1757
1758         prop = RNA_def_property(srna, "uv", PROP_FLOAT, PROP_XYZ);
1759         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1760
1761         prop = RNA_def_property(srna, "pin_uv", PROP_BOOLEAN, PROP_NONE);
1762         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_PINNED);
1763         RNA_def_property_ui_text(prop, "UV Pinned", "");
1764
1765         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1766         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_VERTSEL);
1767         RNA_def_property_ui_text(prop, "UV Select", "");
1768
1769         prop = RNA_def_property(srna, "select_edge", PROP_BOOLEAN, PROP_NONE);
1770         RNA_def_property_boolean_sdna(prop, NULL, "flag", MLOOPUV_EDGESEL);
1771         RNA_def_property_ui_text(prop, "UV Edge Select", "");
1772 }
1773
1774 static void rna_def_mtface(BlenderRNA *brna)
1775 {
1776         StructRNA *srna;
1777         PropertyRNA *prop;
1778         const int uv_dim[] = {4, 2};
1779
1780         srna = RNA_def_struct(brna, "MeshTextureFaceLayer", NULL);
1781         RNA_def_struct_ui_text(srna, "Mesh UV Map", "UV map with assigned image textures in a Mesh datablock");
1782         RNA_def_struct_sdna(srna, "CustomDataLayer");
1783         RNA_def_struct_path_func(srna, "rna_MeshTextureFaceLayer_path");
1784         RNA_def_struct_ui_icon(srna, ICON_GROUP_UVS);
1785
1786         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1787         RNA_def_struct_name_property(srna, prop);
1788         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshTextureFaceLayer_name_set");
1789         RNA_def_property_ui_text(prop, "Name", "Name of UV map");
1790         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1791
1792         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1793         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_get", "rna_MeshTextureFaceLayer_active_set");
1794         RNA_def_property_ui_text(prop, "Active", "Set the map as active for display and editing");
1795         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1796
1797         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1798         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1799         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_render_get",
1800                                        "rna_MeshTextureFaceLayer_active_render_set");
1801         RNA_def_property_ui_text(prop, "Active Render", "Set the map as active for rendering");
1802         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1803
1804         prop = RNA_def_property(srna, "active_clone", PROP_BOOLEAN, PROP_NONE);
1805         RNA_def_property_boolean_sdna(prop, NULL, "active_clone", 0);
1806         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_clone_get", "rna_MeshTextureFaceLayer_clone_set");
1807         RNA_def_property_ui_text(prop, "Active Clone", "Set the map as active for cloning");
1808         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1809
1810         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1811         RNA_def_property_struct_type(prop, "MeshTextureFace");
1812         RNA_def_property_ui_text(prop, "Data", "");
1813         RNA_def_property_collection_funcs(prop, "rna_MeshTextureFaceLayer_data_begin", "rna_iterator_array_next",
1814                                           "rna_iterator_array_end", "rna_iterator_array_get",
1815                                           "rna_MeshTextureFaceLayer_data_length", NULL, NULL, NULL);
1816
1817         srna = RNA_def_struct(brna, "MeshTextureFace", NULL);
1818         RNA_def_struct_sdna(srna, "MTFace");
1819         RNA_def_struct_ui_text(srna, "Mesh UV Map Face", "UV map and image texture for a face");
1820         RNA_def_struct_path_func(srna, "rna_MeshTextureFace_path");
1821         RNA_def_struct_ui_icon(srna, ICON_FACESEL_HLT);
1822
1823         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1824         RNA_def_property_pointer_sdna(prop, NULL, "tpage");
1825         RNA_def_property_pointer_funcs(prop, NULL, "rna_TextureFace_image_set", NULL, NULL);
1826         RNA_def_property_flag(prop, PROP_EDITABLE);
1827         RNA_def_property_ui_text(prop, "Image", "");
1828         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1829
1830         /* these are for editing only, access at loops now */
1831 #if 0
1832         prop = RNA_def_property(srna, "select_uv", PROP_BOOLEAN, PROP_NONE);
1833         RNA_def_property_boolean_sdna(prop, NULL, "flag", TF_SEL1);
1834         RNA_def_property_array(prop, 4);
1835         RNA_def_property_ui_text(prop, "UV Selected", "");
1836         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1837
1838         prop = RNA_def_property(srna, "pin_uv", PROP_BOOLEAN, PROP_NONE);
1839         RNA_def_property_boolean_sdna(prop, NULL, "unwrap", TF_PIN1);
1840         RNA_def_property_array(prop, 4);
1841         RNA_def_property_ui_text(prop, "UV Pinned", "");
1842         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1843 #endif
1844
1845         prop = RNA_def_property(srna, "uv1", PROP_FLOAT, PROP_XYZ);
1846         RNA_def_property_array(prop, 2);
1847         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv1_get", "rna_MeshTextureFace_uv1_set", NULL);
1848         RNA_def_property_ui_text(prop, "UV 1", "");
1849         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1850
1851         prop = RNA_def_property(srna, "uv2", PROP_FLOAT, PROP_XYZ);
1852         RNA_def_property_array(prop, 2);
1853         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv2_get", "rna_MeshTextureFace_uv2_set", NULL);
1854         RNA_def_property_ui_text(prop, "UV 2", "");
1855         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1856
1857         prop = RNA_def_property(srna, "uv3", PROP_FLOAT, PROP_XYZ);
1858         RNA_def_property_array(prop, 2);
1859         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv3_get", "rna_MeshTextureFace_uv3_set", NULL);
1860         RNA_def_property_ui_text(prop, "UV 3", "");
1861         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1862
1863         prop = RNA_def_property(srna, "uv4", PROP_FLOAT, PROP_XYZ);
1864         RNA_def_property_array(prop, 2);
1865         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv4_get", "rna_MeshTextureFace_uv4_set", NULL);
1866         RNA_def_property_ui_text(prop, "UV 4", "");
1867         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1868
1869         prop = RNA_def_property(srna, "uv", PROP_FLOAT, PROP_NONE);
1870         RNA_def_property_multi_array(prop, 2, uv_dim);
1871         RNA_def_property_flag(prop, PROP_DYNAMIC);
1872         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshTextureFace_uv_get_length");
1873         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv_get", "rna_MeshTextureFace_uv_set", NULL);
1874         RNA_def_property_ui_text(prop, "UV", "");
1875         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1876
1877         prop = RNA_def_property(srna, "uv_raw", PROP_FLOAT, PROP_NONE);
1878         RNA_def_property_multi_array(prop, 2, uv_dim);
1879         RNA_def_property_float_sdna(prop, NULL, "uv");
1880         RNA_def_property_ui_text(prop, "UV", "Fixed size UV coordinates array");
1881
1882 }
1883
1884 static void rna_def_mtexpoly(BlenderRNA *brna)
1885 {
1886         StructRNA *srna;
1887         PropertyRNA *prop;
1888 #if 0  /* BMESH_TODO: needed later when do another todo */
1889         int uv_dim[] = {4, 2};
1890 #endif
1891
1892         srna = RNA_def_struct(brna, "MeshTexturePolyLayer", NULL);
1893         RNA_def_struct_ui_text(srna, "Mesh UV Map", "UV map with assigned image textures in a Mesh datablock");
1894         RNA_def_struct_sdna(srna, "CustomDataLayer");
1895         RNA_def_struct_path_func(srna, "rna_MeshTexturePolyLayer_path");
1896         RNA_def_struct_ui_icon(srna, ICON_GROUP_UVS);
1897
1898         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1899         RNA_def_struct_name_property(srna, prop);
1900         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshTexturePolyLayer_name_set");
1901         RNA_def_property_ui_text(prop, "Name", "Name of UV map");
1902         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1903
1904         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1905         RNA_def_property_boolean_funcs(prop, "rna_MeshTexturePolyLayer_active_get", "rna_MeshTexturePolyLayer_active_set");
1906         RNA_def_property_ui_text(prop, "Active", "Set the map as active for display and editing");
1907         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1908
1909         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1910         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1911         RNA_def_property_boolean_funcs(prop, "rna_MeshTexturePolyLayer_active_render_get",
1912                                        "rna_MeshTexturePolyLayer_active_render_set");
1913         RNA_def_property_ui_text(prop, "Active Render", "Set the map as active for rendering");
1914         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1915
1916         prop = RNA_def_property(srna, "active_clone", PROP_BOOLEAN, PROP_NONE);
1917         RNA_def_property_boolean_sdna(prop, NULL, "active_clone", 0);
1918         RNA_def_property_boolean_funcs(prop, "rna_MeshTexturePolyLayer_clone_get", "rna_MeshTexturePolyLayer_clone_set");
1919         RNA_def_property_ui_text(prop, "Active Clone", "Set the map as active for cloning");
1920         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1921
1922         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1923         RNA_def_property_struct_type(prop, "MeshTexturePoly");
1924         RNA_def_property_ui_text(prop, "Data", "");
1925         RNA_def_property_collection_funcs(prop, "rna_MeshTexturePolyLayer_data_begin", "rna_iterator_array_next",
1926                                           "rna_iterator_array_end", "rna_iterator_array_get",
1927                                           "rna_MeshTexturePolyLayer_data_length", NULL, NULL, NULL);
1928
1929         srna = RNA_def_struct(brna, "MeshTexturePoly", NULL);
1930         RNA_def_struct_sdna(srna, "MTexPoly");
1931         RNA_def_struct_ui_text(srna, "Mesh UV Map Face", "UV map and image texture for a face");
1932         RNA_def_struct_path_func(srna, "rna_MeshTexturePoly_path");
1933         RNA_def_struct_ui_icon(srna, ICON_FACESEL_HLT);
1934
1935         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1936         RNA_def_property_pointer_sdna(prop, NULL, "tpage");
1937         RNA_def_property_pointer_funcs(prop, NULL, "rna_TexturePoly_image_set", NULL, NULL);
1938         RNA_def_property_flag(prop, PROP_EDITABLE);
1939         RNA_def_property_ui_text(prop, "Image", "");
1940         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1941
1942 #if 0 /* moved to MeshUVLoopLayer */
1943         prop = RNA_def_property(srna, "select_uv", PROP_BOOLEAN, PROP_NONE);
1944         RNA_def_property_boolean_sdna(prop, NULL, "flag", TF_SEL1);
1945         RNA_def_property_array(prop, 4);
1946         RNA_def_property_ui_text(prop, "UV Selected", "");
1947         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1948
1949         prop = RNA_def_property(srna, "pin_uv", PROP_BOOLEAN, PROP_NONE);
1950         RNA_def_property_boolean_sdna(prop, NULL, "unwrap", TF_PIN1);
1951         RNA_def_property_array(prop, 4);
1952         RNA_def_property_ui_text(prop, "UV Pinned", "");
1953         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1954
1955         prop = RNA_def_property(srna, "uv_raw", PROP_FLOAT, PROP_NONE);
1956         RNA_def_property_multi_array(prop, 2, uv_dim);
1957         RNA_def_property_float_sdna(prop, NULL, "uv");
1958         RNA_def_property_ui_text(prop, "UV", "Fixed size UV coordinates array");
1959 #endif
1960 }
1961
1962 static void rna_def_mcol(BlenderRNA *brna)
1963 {
1964         StructRNA *srna;
1965         PropertyRNA *prop;
1966
1967         srna = RNA_def_struct(brna, "MeshColorLayer", NULL);
1968         RNA_def_struct_ui_text(srna, "Mesh Vertex Color Layer", "Layer of vertex colors in a Mesh datablock");
1969         RNA_def_struct_sdna(srna, "CustomDataLayer");
1970         RNA_def_struct_path_func(srna, "rna_MeshColorLayer_path");
1971         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
1972
1973         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1974         RNA_def_struct_name_property(srna, prop);
1975         RNA_def_property_string_funcs(prop, NULL, NULL, NULL);
1976         RNA_def_property_ui_text(prop, "Name", "Name of Vertex color layer");
1977         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1978
1979         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1980         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_get", "rna_MeshColorLayer_active_set");
1981         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1982         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1983
1984         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1985         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1986         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_render_get",
1987                                        "rna_MeshColorLayer_active_render_set");
1988         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1989         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1990
1991         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1992         RNA_def_property_struct_type(prop, "MeshColor");
1993         RNA_def_property_ui_text(prop, "Data", "");
1994         RNA_def_property_collection_funcs(prop, "rna_MeshColorLayer_data_begin", "rna_iterator_array_next",
1995                                           "rna_iterator_array_end", "rna_iterator_array_get",
1996                                           "rna_MeshColorLayer_data_length", NULL, NULL, NULL);
1997
1998         srna = RNA_def_struct(brna, "MeshColor", NULL);
1999         RNA_def_struct_sdna(srna, "MCol");
2000         RNA_def_struct_ui_text(srna, "Mesh Vertex Color", "Vertex colors for a face in a Mesh");
2001         RNA_def_struct_path_func(srna, "rna_MeshColor_path");
2002
2003         prop = RNA_def_property(srna, "color1", PROP_FLOAT, PROP_COLOR);
2004         RNA_def_property_array(prop, 3);
2005         RNA_def_property_range(prop, 0.0f, 1.0f);
2006         RNA_def_property_float_funcs(prop, "rna_MeshColor_color1_get", "rna_MeshColor_color1_set", NULL);
2007         RNA_def_property_ui_text(prop, "Color 1", "");
2008         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2009
2010         prop = RNA_def_property(srna, "color2", PROP_FLOAT, PROP_COLOR);
2011         RNA_def_property_array(prop, 3);
2012         RNA_def_property_range(prop, 0.0f, 1.0f);
2013         RNA_def_property_float_funcs(prop, "rna_MeshColor_color2_get", "rna_MeshColor_color2_set", NULL);
2014         RNA_def_property_ui_text(prop, "Color 2", "");
2015         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2016
2017         prop = RNA_def_property(srna, "color3", PROP_FLOAT, PROP_COLOR);
2018         RNA_def_property_array(prop, 3);
2019         RNA_def_property_range(prop, 0.0f, 1.0f);
2020         RNA_def_property_float_funcs(prop, "rna_MeshColor_color3_get", "rna_MeshColor_color3_set", NULL);
2021         RNA_def_property_ui_text(prop, "Color 3", "");
2022         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2023
2024         prop = RNA_def_property(srna, "color4", PROP_FLOAT, PROP_COLOR);
2025         RNA_def_property_array(prop, 3);
2026         RNA_def_property_range(prop, 0.0f, 1.0f);
2027         RNA_def_property_float_funcs(prop, "rna_MeshColor_color4_get", "rna_MeshColor_color4_set", NULL);
2028         RNA_def_property_ui_text(prop, "Color 4", "");
2029         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2030 }
2031
2032 static void rna_def_mloopcol(BlenderRNA *brna)
2033 {
2034         StructRNA *srna;
2035         PropertyRNA *prop;
2036
2037         srna = RNA_def_struct(brna, "MeshLoopColorLayer", NULL);
2038         RNA_def_struct_ui_text(srna, "Mesh Vertex Color Layer", "Layer of vertex colors in a Mesh datablock");
2039         RNA_def_struct_sdna(srna, "CustomDataLayer");
2040         RNA_def_struct_path_func(srna, "rna_MeshLoopColorLayer_path");
2041         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
2042
2043         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2044         RNA_def_struct_name_property(srna, prop);
2045         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshLoopColorLayer_name_set");
2046         RNA_def_property_ui_text(prop, "Name", "Name of Vertex color layer");
2047         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2048
2049         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
2050         RNA_def_property_boolean_funcs(prop, "rna_MeshLoopColorLayer_active_get", "rna_MeshLoopColorLayer_active_set");
2051         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
2052         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2053
2054         prop = RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
2055         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
2056         RNA_def_property_boolean_funcs(prop, "rna_MeshLoopColorLayer_active_render_get",
2057                                        "rna_MeshLoopColorLayer_active_render_set");
2058         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
2059         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2060
2061         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2062         RNA_def_property_struct_type(prop, "MeshLoopColor");
2063         RNA_def_property_ui_text(prop, "Data", "");
2064         RNA_def_property_collection_funcs(prop, "rna_MeshLoopColorLayer_data_begin", "rna_iterator_array_next",
2065                                           "rna_iterator_array_end", "rna_iterator_array_get",
2066                                           "rna_MeshLoopColorLayer_data_length", NULL, NULL, NULL);
2067
2068
2069         srna = RNA_def_struct(brna, "MeshLoopColor", NULL);
2070         RNA_def_struct_sdna(srna, "MLoopCol");
2071         RNA_def_struct_ui_text(srna, "Mesh Vertex Color", "Vertex loop colors in a Mesh");
2072         RNA_def_struct_path_func(srna, "rna_MeshColor_path");
2073
2074         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
2075         RNA_def_property_array(prop, 3);
2076         RNA_def_property_range(prop, 0.0f, 1.0f);
2077         RNA_def_property_float_funcs(prop, "rna_MeshLoopColor_color_get", "rna_MeshLoopColor_color_set", NULL);
2078         RNA_def_property_ui_text(prop, "Color", "");
2079         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2080 }
2081
2082 static void rna_def_mproperties(BlenderRNA *brna)
2083 {
2084         StructRNA *srna;
2085         PropertyRNA *prop;
2086
2087         /* Float */
2088         srna = RNA_def_struct(brna, "MeshFloatPropertyLayer", NULL);
2089         RNA_def_struct_sdna(srna, "CustomDataLayer");
2090         RNA_def_struct_ui_text(srna, "Mesh Float Property Layer", "User defined layer of floating point number values");
2091         RNA_def_struct_path_func(srna, "rna_MeshFloatPropertyLayer_path");
2092
2093         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2094         RNA_def_struct_name_property(srna, prop);
2095         RNA_def_property_ui_text(prop, "Name", "");
2096         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2097
2098         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2099         RNA_def_property_struct_type(prop, "MeshFloatProperty");
2100         RNA_def_property_ui_text(prop, "Data", "");
2101         RNA_def_property_collection_funcs(prop, "rna_MeshFloatPropertyLayer_data_begin", "rna_iterator_array_next",
2102                                           "rna_iterator_array_end", "rna_iterator_array_get",
2103                                           "rna_MeshFloatPropertyLayer_data_length", NULL, NULL, NULL);
2104
2105         srna = RNA_def_struct(brna, "MeshFloatProperty", NULL);
2106         RNA_def_struct_sdna(srna, "MFloatProperty");
2107         RNA_def_struct_ui_text(srna, "Mesh Float Property",
2108                                "User defined floating point number value in a float properties layer");
2109         RNA_def_struct_path_func(srna, "rna_MeshFloatProperty_path");
2110
2111         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
2112         RNA_def_property_float_sdna(prop, NULL, "f");
2113         RNA_def_property_ui_text(prop, "Value", "");
2114         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2115
2116         /* Int */
2117         srna = RNA_def_struct(brna, "MeshIntPropertyLayer", NULL);
2118         RNA_def_struct_sdna(srna, "CustomDataLayer");
2119         RNA_def_struct_ui_text(srna, "Mesh Int Property Layer", "User defined layer of integer number values");
2120         RNA_def_struct_path_func(srna, "rna_MeshIntPropertyLayer_path");
2121
2122         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2123         RNA_def_struct_name_property(srna, prop);
2124         RNA_def_property_ui_text(prop, "Name", "");
2125         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2126
2127         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2128         RNA_def_property_struct_type(prop, "MeshIntProperty");
2129         RNA_def_property_ui_text(prop, "Data", "");
2130         RNA_def_property_collection_funcs(prop, "rna_MeshIntPropertyLayer_data_begin", "rna_iterator_array_next",
2131                                           "rna_iterator_array_end", "rna_iterator_array_get",
2132                                           "rna_MeshIntPropertyLayer_data_length", NULL, NULL, NULL);
2133
2134         srna = RNA_def_struct(brna, "MeshIntProperty", NULL);
2135         RNA_def_struct_sdna(srna, "MIntProperty");
2136         RNA_def_struct_ui_text(srna, "Mesh Int Property",
2137                                "User defined integer number value in an integer properties layer");
2138         RNA_def_struct_path_func(srna, "rna_MeshIntProperty_path");
2139
2140         prop = RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
2141         RNA_def_property_int_sdna(prop, NULL, "i");
2142         RNA_def_property_ui_text(prop, "Value", "");
2143         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2144
2145         /* String */
2146         srna = RNA_def_struct(brna, "MeshStringPropertyLayer", NULL);
2147         RNA_def_struct_sdna(srna, "CustomDataLayer");
2148         RNA_def_struct_ui_text(srna, "Mesh String Property Layer", "User defined layer of string text values");
2149         RNA_def_struct_path_func(srna, "rna_MeshStringPropertyLayer_path");
2150
2151         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2152         RNA_def_struct_name_property(srna, prop);
2153         RNA_def_property_ui_text(prop, "Name", "");
2154         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2155
2156         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2157         RNA_def_property_struct_type(prop, "MeshStringProperty");
2158         RNA_def_property_ui_text(prop, "Data", "");
2159         RNA_def_property_collection_funcs(prop, "rna_MeshStringPropertyLayer_data_begin", "rna_iterator_array_next",
2160                                           "rna_iterator_array_end", "rna_iterator_array_get",
2161                                           "rna_MeshStringPropertyLayer_data_length", NULL, NULL, NULL);
2162
2163         srna = RNA_def_struct(brna, "MeshStringProperty", NULL);
2164         RNA_def_struct_sdna(srna, "MStringProperty");
2165         RNA_def_struct_ui_text(srna, "Mesh String Property",
2166                                "User defined string text value in a string properties layer");
2167         RNA_def_struct_path_func(srna, "rna_MeshStringProperty_path");
2168
2169         /* low level mesh data access, treat as bytes */
2170         prop = RNA_def_property(srna, "value", PROP_STRING, PROP_BYTESTRING);
2171         RNA_def_property_string_sdna(prop, NULL, "s");
2172         RNA_def_property_ui_text(prop, "Value", "");
2173         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2174 }
2175
2176 void rna_def_texmat_common(StructRNA *srna, const char *texspace_editable)
2177 {
2178         PropertyRNA *prop;
2179
2180         /* texture space */
2181         prop = RNA_def_property(srna, "auto_texspace", PROP_BOOLEAN, PROP_NONE);
2182         RNA_def_property_boolean_sdna(prop, NULL, "texflag", ME_AUTOSPACE);
2183         RNA_def_property_ui_text(prop, "Auto Texture Space",
2184                                  "Adjust active object's texture space automatically when transforming object");
2185
2186         prop = RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
2187         RNA_def_property_float_sdna(prop, NULL, "loc");
2188         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
2189         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_loc_get", NULL, NULL);
2190         RNA_def_property_editable_func(prop, texspace_editable);
2191         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2192
2193         prop = RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
2194         RNA_def_property_float_sdna(prop, NULL, "size");
2195         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size");
2196         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_size_get", NULL, NULL);
2197         RNA_def_property_editable_func(prop, texspace_editable);
2198         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2199
2200         /* not supported yet */
2201 #if 0
2202         prop = RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
2203         RNA_def_property_float(prop, NULL, "rot");
2204         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
2205         RNA_def_property_editable_func(prop, texspace_editable);
2206         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2207 #endif
2208
2209         /* materials */
2210         prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
2211         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
2212         RNA_def_property_struct_type(prop, "Material");
2213         RNA_def_property_ui_text(prop, "Materials", "");
2214         RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
2215         RNA_def_property_collection_funcs(prop, 0, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
2216 }
2217
2218
2219 /* scene.objects */
2220 /* mesh.vertices */
2221 static void rna_def_mesh_vertices(BlenderRNA *brna, PropertyRNA *cprop)
2222 {
2223         StructRNA *srna;
2224 /*      PropertyRNA *prop; */
2225
2226         FunctionRNA *func;
2227 /*      PropertyRNA *parm; */
2228
2229         RNA_def_property_srna(cprop, "MeshVertices");
2230         srna = RNA_def_struct(brna, "MeshVertices", NULL);
2231         RNA_def_struct_sdna(srna, "Mesh");
2232         RNA_def_struct_ui_text(srna, "Mesh Vertices", "Collection of mesh vertices");
2233
2234         func = RNA_def_function(srna, "add", "ED_mesh_vertices_add");
2235         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2236         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to add", 0, INT_MAX);
2237 #if 0 /* BMESH_TODO Remove until BMesh merge */
2238         func = RNA_def_function(srna, "remove", "ED_mesh_vertices_remove");
2239         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2240         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to remove", 0, INT_MAX);
2241 #endif
2242 }
2243
2244 /* mesh.edges */
2245 static void rna_def_mesh_edges(BlenderRNA *brna, PropertyRNA *cprop)
2246 {
2247         StructRNA *srna;
2248 /*      PropertyRNA *prop; */
2249
2250         FunctionRNA *func;
2251 /*      PropertyRNA *parm; */
2252
2253         RNA_def_property_srna(cprop, "MeshEdges");
2254         srna = RNA_def_struct(brna, "MeshEdges", NULL);
2255         RNA_def_struct_sdna(srna, "Mesh");
2256         RNA_def_struct_ui_text(srna, "Mesh Edges", "Collection of mesh edges");
2257
2258         func = RNA_def_function(srna, "add", "ED_mesh_edges_add");
2259         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2260         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of edges to add", 0, INT_MAX);
2261 #if 0 /* BMESH_TODO Remove until BMesh merge */
2262         func = RNA_def_function(srna, "remove", "ED_mesh_edges_remove");
2263         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2264         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of edges to remove", 0, INT_MAX);
2265 #endif
2266 }
2267
2268 /* mesh.faces */
2269 static void rna_def_mesh_tessfaces(BlenderRNA *brna, PropertyRNA *cprop)
2270 {
2271         StructRNA *srna;
2272         PropertyRNA *prop;
2273
2274         FunctionRNA *func;
2275 /*      PropertyRNA *parm; */
2276
2277         RNA_def_property_srna(cprop, "MeshTessFaces");
2278         srna = RNA_def_struct(brna, "MeshTessFaces", NULL);
2279         RNA_def_struct_sdna(srna, "Mesh");
2280         RNA_def_struct_ui_text(srna, "Mesh Faces", "Collection of mesh faces");
2281
2282         prop = RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
2283         RNA_def_property_int_sdna(prop, NULL, "act_face");
2284         RNA_def_property_ui_text(prop, "Active Face", "The active face for this mesh");
2285
2286         func = RNA_def_function(srna, "add", "ED_mesh_tessfaces_add");
2287         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2288         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of faces to add", 0, INT_MAX);
2289 #if 0 /* BMESH_TODO Remove until BMesh merge */
2290         func = RNA_def_function(srna, "remove", "ED_mesh_faces_remove");
2291         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2292         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of faces to remove", 0, INT_MAX);
2293 #endif
2294 }
2295
2296 /* mesh.loops */
2297 static void rna_def_mesh_loops(BlenderRNA *brna, PropertyRNA *cprop)
2298 {
2299         StructRNA *srna;
2300
2301         /*PropertyRNA *prop;*/
2302
2303         FunctionRNA *func;
2304         /*PropertyRNA *parm;*/
2305
2306         RNA_def_property_srna(cprop, "MeshLoops");
2307         srna = RNA_def_struct(brna, "MeshLoops", NULL);
2308         RNA_def_struct_sdna(srna, "Mesh");
2309         RNA_def_struct_ui_text(srna, "Mesh Loops", "Collection of mesh loops");
2310
2311         func = RNA_def_function(srna, "add", "ED_mesh_loops_add");
2312         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2313         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of loops to add", 0, INT_MAX);
2314 }
2315
2316 /* mesh.polygons */
2317 static void rna_def_mesh_polygons(BlenderRNA *brna, PropertyRNA *cprop)
2318 {
2319         StructRNA *srna;
2320
2321         PropertyRNA *prop;
2322
2323         FunctionRNA *func;
2324         /* PropertyRNA *parm; */
2325
2326         RNA_def_property_srna(cprop, "MeshPolygons");
2327         srna = RNA_def_struct(brna, "MeshPolygons", NULL);
2328         RNA_def_struct_sdna(srna, "Mesh");
2329         RNA_def_struct_ui_text(srna, "Mesh Polygons", "Collection of mesh polygons");
2330
2331         prop = RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
2332         RNA_def_property_int_sdna(prop, NULL, "act_face");
2333         RNA_def_property_ui_text(prop, "Active Polygon", "The active polygon for this mesh");
2334
2335         func = RNA_def_function(srna, "add", "ED_mesh_polys_add");
2336         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2337         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of polygons to add", 0, INT_MAX);
2338 }
2339
2340
2341 /* mesh.vertex_colors */
2342 static void rna_def_tessface_vertex_colors(BlenderRNA *brna, PropertyRNA *cprop)
2343 {
2344         StructRNA *srna;
2345         PropertyRNA *prop;
2346
2347         FunctionRNA *func;
2348         PropertyRNA *parm;
2349
2350         RNA_def_property_srna(cprop, "VertexColors");
2351         srna = RNA_def_struct(brna, "VertexColors", NULL);
2352         RNA_def_struct_sdna(srna, "Mesh");
2353         RNA_def_struct_ui_text(srna, "Vertex Colors", "Collection of vertex colors");
2354
2355         /* eventually deprecate this */
2356         func = RNA_def_function(srna, "new", "rna_Mesh_tessface_vertex_color_new");
2357         RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2358         RNA_def_function_ui_description(func, "Add a vertex color layer to Mesh");
2359         RNA_def_string(func, "name", "Col", 0, "", "Vertex color name");
2360         parm = RNA_def_pointer(func, "layer", "MeshColorLayer", "", "The newly created layer");
2361         RNA_def_property_flag(parm, PROP_RNAPTR);
2362         RNA_def_function_return(func, parm);
2363
2364         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2365         RNA_def_property_struct_type(prop, "MeshColorLayer");
2366         RNA_def_property_pointer_funcs(prop, "rna_Mesh_tessface_vertex_color_active_get",
2367                                        "rna_Mesh_tessface_vertex_color_active_set", NULL, NULL);
2368         RNA_def_property_ui_text(prop, "Active Vertex Color Layer", "Active vertex color layer");
2369         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2370
2371         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2372         RNA_def_property_int_funcs(prop, "rna_Mesh_tessface_vertex_color_active_index_get",
2373                                    "rna_Mesh_tessface_vertex_color_active_index_set", "rna_Mesh_vertex_color_index_range");
2374         RNA_def_property_ui_text(prop, "Active Vertex Color Index", "Active vertex color index");
2375         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2376 }
2377
2378 static void rna_def_loop_colors(BlenderRNA *brna, PropertyRNA *cprop)
2379 {
2380         StructRNA *srna;
2381         PropertyRNA *prop;
2382
2383         FunctionRNA *func;
2384         PropertyRNA *parm;
2385
2386         RNA_def_property_srna(cprop, "LoopColors");
2387         srna = RNA_def_struct(brna, "LoopColors", NULL);
2388         RNA_def_struct_sdna(srna, "Mesh");
2389         RNA_def_struct_ui_text(srna, "Loop Colors", "Collection of vertex colors");
2390
2391         func = RNA_def_function(srna, "new", "rna_Mesh_vertex_color_new");
2392         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2393         RNA_def_function_ui_description(func, "Add a vertex color layer to Mesh");
2394         RNA_def_string(func, "name", "Col", 0, "", "Vertex color name");
2395         parm = RNA_def_pointer(func, "layer", "MeshLoopColorLayer", "", "The newly created layer");
2396         RNA_def_property_flag(parm, PROP_RNAPTR);
2397         RNA_def_function_return(func, parm);
2398
2399 #if 0
2400         func = RNA_def_function(srna, "remove", "rna_Mesh_vertex_color_remove");
2401         RNA_def_function_ui_description(func, "Remove a vertex color layer");
2402         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2403         parm = RNA_def_pointer(func, "layer", "Layer", "", "The layer to remove");
2404         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
2405         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2406 #endif
2407
2408         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2409         RNA_def_property_struct_type(prop, "MeshLoopColorLayer");
2410         RNA_def_property_pointer_funcs(prop, "rna_Mesh_vertex_color_active_get",
2411                                        "rna_Mesh_vertex_color_active_set", NULL, NULL);
2412         RNA_def_property_flag(prop, PROP_EDITABLE);
2413         RNA_def_property_ui_text(prop, "Active Vertex Color Layer", "Active vertex color layer");
2414         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2415
2416         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2417         RNA_def_property_int_funcs(prop, "rna_Mesh_vertex_color_active_index_get",
2418                                    "rna_Mesh_vertex_color_active_index_set", "rna_Mesh_vertex_color_index_range");
2419         RNA_def_property_ui_text(prop, "Active Vertex Color Index", "Active vertex color index");
2420         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2421 }
2422
2423 static void rna_def_uv_layers(BlenderRNA *brna, PropertyRNA *cprop)
2424 {
2425         StructRNA *srna;
2426         PropertyRNA *prop;
2427
2428         /* FunctionRNA *func; */
2429         /* PropertyRNA *parm; */
2430
2431         RNA_def_property_srna(cprop, "UVLoopLayers");
2432         srna = RNA_def_struct(brna, "UVLoopLayers", NULL);
2433         RNA_def_struct_sdna(srna, "Mesh");
2434         RNA_def_struct_ui_text(srna, "UV Loop Layers", "Collection of uv loop layers");
2435
2436         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2437         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2438         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_active_get",
2439                                        "rna_Mesh_uv_layer_active_set", NULL, NULL);
2440         RNA_def_property_flag(prop, PROP_EDITABLE);
2441         RNA_def_property_ui_text(prop, "Active UV loop layer", "Active UV loop layer");
2442         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2443
2444         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2445         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_active_index_get",
2446                                    "rna_Mesh_uv_layer_active_index_set", "rna_Mesh_uv_layer_index_range");
2447         RNA_def_property_ui_text(prop, "Active UV loop layer Index", "Active UV loop layer index");
2448         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2449 }
2450
2451 /* mesh int layers */
2452 static void rna_def_polygon_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
2453 {
2454         StructRNA *srna;
2455
2456         FunctionRNA *func;
2457         PropertyRNA *parm;
2458
2459         RNA_def_property_srna(cprop, "IntProperties");
2460         srna = RNA_def_struct(brna, "IntProperties", NULL);
2461         RNA_def_struct_sdna(srna, "Mesh");
2462         RNA_def_struct_ui_text(srna, "Int Properties", "Collection of int properties");
2463
2464         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_int_property_new");
2465         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2466         RNA_def_function_ui_description(func, "Add a integer property layer to Mesh");
2467         RNA_def_string(func, "name", "Int Prop", 0, "",  "Int property name");
2468         parm = RNA_def_pointer(func, "layer", "MeshIntPropertyLayer", "", "The newly created layer");
2469         RNA_def_property_flag(parm, PROP_RNAPTR);
2470         RNA_def_function_return(func, parm);
2471 }
2472
2473 /* mesh float layers */
2474 static void rna_def_polygon_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
2475 {
2476         StructRNA *srna;
2477
2478         FunctionRNA *func;
2479         PropertyRNA *parm;
2480
2481         RNA_def_property_srna(cprop, "FloatProperties");
2482         srna = RNA_def_struct(brna, "FloatProperties", NULL);
2483         RNA_def_struct_sdna(srna, "Mesh");
2484         RNA_def_struct_ui_text(srna, "Float Properties", "Collection of float properties");
2485
2486         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_float_property_new");
2487         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2488         RNA_def_function_ui_description(func, "Add a float property layer to Mesh");
2489         RNA_def_string(func, "name", "Float Prop", 0, "", "Float property name");
2490         parm = RNA_def_pointer(func, "layer", "MeshFloatPropertyLayer", "", "The newly created layer");
2491         RNA_def_property_flag(parm, PROP_RNAPTR);
2492         RNA_def_function_return(func, parm);
2493 }
2494
2495 /* mesh string layers */
2496 static void rna_def_polygon_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
2497 {
2498         StructRNA *srna;
2499
2500         FunctionRNA *func;
2501         PropertyRNA *parm;
2502
2503         RNA_def_property_srna(cprop, "StringProperties");
2504         srna = RNA_def_struct(brna, "StringProperties", NULL);
2505         RNA_def_struct_sdna(srna, "Mesh");
2506         RNA_def_struct_ui_text(srna, "String Properties", "Collection of string properties");
2507
2508         func = RNA_def_function(srna, "new", "rna_Mesh_polygon_string_property_new");
2509         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2510         RNA_def_function_ui_description(func, "Add a string property layer to Mesh");
2511         RNA_def_string(func, "name", "String Prop", 0, "", "String property name");
2512         parm = RNA_def_pointer(func, "layer", "MeshStringPropertyLayer", "", "The newly created layer");
2513         RNA_def_property_flag(parm, PROP_RNAPTR);
2514         RNA_def_function_return(func, parm);
2515 }
2516
2517 /* mesh.tessface_uv_layers */
2518 static void rna_def_tessface_uv_textures(BlenderRNA *brna, PropertyRNA *cprop)
2519 {
2520         StructRNA *srna;
2521         PropertyRNA *prop;
2522
2523         FunctionRNA *func;
2524         PropertyRNA *parm;
2525
2526         RNA_def_property_srna(cprop, "TessfaceUVTextures");
2527         srna = RNA_def_struct(brna, "TessfaceUVTextures", NULL);
2528         RNA_def_struct_sdna(srna, "Mesh");
2529         RNA_def_struct_ui_text(srna, "UV Maps", "Collection of UV maps for tessellated faces");
2530
2531         /* eventually deprecate this */
2532         func = RNA_def_function(srna, "new", "rna_Mesh_tessface_uv_texture_new");
2533         RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2534         RNA_def_function_ui_description(func, "Add a UV tessface-texture layer to Mesh (only for meshes with no polygons)");
2535         RNA_def_string(func, "name", "UVMap", 0, "", "UV map name");
2536         parm = RNA_def_pointer(func, "layer", "MeshTextureFaceLayer", "", "The newly created layer");
2537         RNA_def_property_flag(parm, PROP_RNAPTR);
2538         RNA_def_function_return(func, parm);
2539
2540
2541         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2542         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
2543         RNA_def_property_pointer_funcs(prop, "rna_Mesh_tessface_uv_texture_active_get",
2544                                        "rna_Mesh_tessface_uv_texture_active_set", NULL, NULL);
2545         RNA_def_property_ui_text(prop, "Active UV Map", "Active UV Map");
2546         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2547
2548         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2549         RNA_def_property_int_funcs(prop, "rna_Mesh_tessface_uv_texture_active_index_get",
2550                                    "rna_Mesh_tessface_uv_texture_active_index_set", "rna_Mesh_uv_texture_index_range");
2551         RNA_def_property_ui_text(prop, "Active UV Map Index", "Active UV Map index");
2552         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2553 }
2554
2555
2556 static void rna_def_uv_textures(BlenderRNA *brna, PropertyRNA *cprop)
2557 {
2558         StructRNA *srna;
2559         PropertyRNA *prop;
2560
2561         FunctionRNA *func;
2562         PropertyRNA *parm;
2563
2564         RNA_def_property_srna(cprop, "UVTextures");
2565         srna = RNA_def_struct(brna, "UVTextures", NULL);
2566         RNA_def_struct_sdna(srna, "Mesh");
2567         RNA_def_struct_ui_text(srna, "UV Maps", "Collection of UV maps");
2568
2569         func = RNA_def_function(srna, "new", "rna_Mesh_uv_texture_new");
2570         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2571         RNA_def_function_ui_description(func, "Add a UV map layer to Mesh");
2572         RNA_def_string(func, "name", "UVMap", 0, "", "UV map name");
2573         parm = RNA_def_pointer(func, "layer", "MeshTexturePolyLayer", "", "The newly created layer");
2574         RNA_def_property_flag(parm, PROP_RNAPTR);
2575         RNA_def_function_return(func, parm);
2576
2577 #if 0
2578         func = RNA_def_function(srna, "remove", "rna_Mesh_uv_texture_layers_remove");
2579         RNA_def_function_ui_description(func, "Remove a vertex color layer");
2580         RNA_def_function_flag(func, FUNC_USE_REPORTS);
2581         parm = RNA_def_pointer(func, "layer", "Layer", "", "The layer to remove");
2582         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
2583         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2584 #endif
2585
2586         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2587         RNA_def_property_struct_type(prop, "MeshTexturePolyLayer");
2588         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_texture_active_get",
2589                                        "rna_Mesh_uv_texture_active_set", NULL, NULL);
2590         RNA_def_property_flag(prop, PROP_EDITABLE);
2591         RNA_def_property_ui_text(prop, "Active UV Map", "Active UV Map");
2592         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2593
2594         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2595         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_texture_active_index_get",
2596                                    "rna_Mesh_uv_texture_active_index_set", "rna_Mesh_uv_texture_index_range");
2597         RNA_def_property_ui_text(prop, "Active UV Map Index", "Active UV Map index");
2598         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2599 }
2600
2601 static void rna_def_skin_vertices(BlenderRNA *brna, PropertyRNA *UNUSED(cprop))
2602 {
2603         StructRNA *srna;
2604         PropertyRNA *prop;
2605
2606         srna = RNA_def_struct(brna, "MeshSkinVertexLayer", NULL);
2607         RNA_def_struct_ui_text(srna, "Mesh Skin Vertex Layer", "Per-vertex skin data for use with the Skin modifier");
2608         RNA_def_struct_sdna(srna, "CustomDataLayer");
2609         RNA_def_struct_path_func(srna, "rna_MeshSkinVertexLayer_path");
2610
2611         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2612         RNA_def_struct_name_property(srna, prop);
2613         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshSkinVertexLayer_name_set");
2614         RNA_def_property_ui_text(prop, "Name", "Name of skin layer");
2615         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2616
2617         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
2618         RNA_def_property_struct_type(prop, "MeshSkinVertex");
2619         RNA_def_property_ui_text(prop, "Data", "");
2620         RNA_def_property_collection_funcs(prop, "rna_MeshSkinVertexLayer_data_begin", "rna_iterator_array_next",
2621                                           "rna_iterator_array_end", "rna_iterator_array_get",
2622                                           "rna_MeshSkinVertexLayer_data_length", NULL, NULL, NULL);
2623
2624         /* SkinVertex struct */
2625         srna = RNA_def_struct(brna, "MeshSkinVertex", NULL);
2626         RNA_def_struct_sdna(srna, "MVertSkin");
2627         RNA_def_struct_ui_text(srna, "Skin Vertex", "Per-vertex skin data for use with the Skin modifier");
2628         RNA_def_struct_path_func(srna, "rna_MeshSkinVertex_path");
2629
2630         prop = RNA_def_property(srna, "radius", PROP_FLOAT, PROP_NONE);
2631         RNA_def_property_array(prop, 2);
2632         RNA_def_property_ui_range(prop, 0.001, 100, 1, 3);
2633         RNA_def_property_ui_text(prop, "Radius", "Radius of the skin");
2634         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2635
2636         /* Flags */
2637
2638         prop = RNA_def_property(srna, "use_root", PROP_BOOLEAN, PROP_NONE);
2639         RNA_def_property_boolean_sdna(prop, NULL, "flag", MVERT_SKIN_ROOT);
2640         RNA_def_property_ui_text(prop, "Root", "Vertex is a root for rotation calculations and armature generation");
2641         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2642         
2643         prop = RNA_def_property(srna, "use_loose", PROP_BOOLEAN, PROP_NONE);
2644         RNA_def_property_boolean_sdna(prop, NULL, "flag", MVERT_SKIN_LOOSE);
2645         RNA_def_property_ui_text(prop, "Loose", "If vertex has multiple adjacent edges, it is hulled to them directly");
2646         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2647 }
2648
2649 static void rna_def_mesh(BlenderRNA *brna)
2650 {
2651         StructRNA *srna;
2652         PropertyRNA *prop;
2653
2654         srna = RNA_def_struct(brna, "Mesh", "ID");
2655         RNA_def_struct_ui_text(srna, "Mesh", "Mesh datablock defining geometric surfaces");
2656         RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
2657
2658         prop = RNA_def_property(srna, "vertices", PROP_COLLECTION, PROP_NONE);
2659         RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
2660         RNA_def_property_struct_type(prop, "MeshVertex");
2661         RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh");
2662         rna_def_mesh_vertices(brna, prop);
2663
2664         prop = RNA_def_property(srna, "edges", PROP_COLLECTION, PROP_NONE);
2665         RNA_def_property_collection_sdna(prop, NULL, "medge", "totedge");
2666         RNA_def_property_struct_type(prop, "MeshEdge");
2667         RNA_def_property_ui_text(prop, "Edges", "Edges of the mesh");
2668         rna_def_mesh_edges(brna, prop);
2669
2670         prop = RNA_def_property(srna, "tessfaces", PROP_COLLECTION, PROP_NONE);
2671         RNA_def_property_collection_sdna(prop, NULL, "mface", "totface");
2672         RNA_def_property_struct_type(prop, "MeshTessFace");
2673         RNA_def_property_ui_text(prop, "TessFaces", "Tessellation faces of the mesh (derived from polygons)");
2674         rna_def_mesh_tessfaces(brna, prop);
2675
2676         prop = RNA_def_property(srna, "loops", PROP_COLLECTION, PROP_NONE);
2677         RNA_def_property_collection_sdna(prop, NULL, "mloop", "totloop");
2678         RNA_def_property_struct_type(prop, "MeshLoop");
2679         RNA_def_property_ui_text(prop, "Loops", "Loops of the mesh (polygon corners)");
2680         rna_def_mesh_loops(brna, prop);
2681
2682         prop = RNA_def_property(srna, "polygons", PROP_COLLECTION, PROP_NONE);
2683         RNA_def_property_collection_sdna(prop, NULL, "mpoly", "totpoly");
2684         RNA_def_property_struct_type(prop, "MeshPolygon");
2685         RNA_def_property_ui_text(prop, "Polygons", "Polygons of the mesh");
2686         rna_def_mesh_polygons(brna, prop);
2687
2688         /* TODO, should this be allowed to be its self? */
2689         prop = RNA_def_property(srna, "texture_mesh", PROP_POINTER, PROP_NONE);
2690         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
2691         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2692         RNA_def_property_ui_text(prop, "Texture Mesh",
2693                                  "Use another mesh for texture indices (vertex indices must be aligned)");
2694
2695         /* UV loop layers */
2696         prop = RNA_def_property(srna, "uv_layers", PROP_COLLECTION, PROP_NONE);
2697         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
2698         RNA_def_property_collection_funcs(prop, "rna_Mesh_uv_layers_begin", NULL, NULL, NULL,
2699                                           "rna_Mesh_uv_layers_length", NULL, NULL, NULL);
2700         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2701         RNA_def_property_ui_text(prop, "UV Loop Layers", "All UV loop layers");
2702         rna_def_uv_layers(brna, prop);
2703
2704         prop = RNA_def_property(srna, "uv_layer_clone", PROP_POINTER, PROP_NONE);
2705         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2706         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_clone_get",
2707                                        "rna_Mesh_uv_layer_clone_set", NULL, NULL);
2708         RNA_def_property_flag(prop, PROP_EDITABLE);
2709         RNA_def_property_ui_text(prop, "Clone UV loop layer", "UV loop layer to be used as cloning source");
2710
2711         prop = RNA_def_property(srna, "uv_layer_clone_index", PROP_INT, PROP_UNSIGNED);
2712         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_clone_index_get",
2713                                    "rna_Mesh_uv_layer_clone_index_set", "rna_Mesh_uv_layer_index_range");
2714         RNA_def_property_ui_text(prop, "Clone UV loop layer Index", "Clone UV loop layer index");
2715
2716         prop = RNA_def_property(srna, "uv_layer_stencil", PROP_POINTER, PROP_NONE);
2717         RNA_def_property_struct_type(prop, "MeshUVLoopLayer");
2718         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_layer_stencil_get",
2719                                        "rna_Mesh_uv_layer_stencil_set", NULL, NULL);
2720         RNA_def_property_flag(prop, PROP_EDITABLE);
2721         RNA_def_property_ui_text(prop, "Mask UV loop layer", "UV loop layer to mask the painted area");
2722
2723         prop = RNA_def_property(srna, "uv_layer_stencil_index", PROP_INT, PROP_UNSIGNED);
2724         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_layer_stencil_index_get",
2725                                    "rna_Mesh_uv_layer_stencil_index_set", "rna_Mesh_uv_layer_index_range");
2726         RNA_def_property_ui_text(prop, "Mask UV loop layer Index", "Mask UV loop layer index");
2727
2728         /* Tessellated face UV maps - used by renderers */
2729         prop = RNA_def_property(srna, "tessface_uv_textures", PROP_COLLECTION, PROP_NONE);
2730         RNA_def_property_collection_sdna(prop, NULL, "fdata.layers", "fdata.totlayer");
2731         RNA_def_property_collection_funcs(prop, "rna_Mesh_tessface_uv_textures_begin", NULL, NULL, NULL,
2732                                           "rna_Mesh_tessface_uv_textures_length", NULL, NULL, NULL);
2733         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
2734         RNA_def_property_ui_text(prop, "Tessellated Face UV Maps",
2735                                  "All UV maps for tessellated faces (read-only, for use by renderers)");
2736         rna_def_tessface_uv_textures(brna, prop);
2737
2738         /* UV maps */
2739         prop = RNA_def_property(srna, "uv_textures", PROP_COLLECTION, PROP_NONE);
2740         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2741         RNA_def_property_collection_funcs(prop, "rna_Mesh_uv_textures_begin", NULL, NULL, NULL,
2742                                           "rna_Mesh_uv_textures_length", NULL, NULL, NULL);
2743         RNA_def_property_struct_type(prop, "MeshTexturePolyLayer");
2744         RNA_def_property_ui_text(prop, "UV Maps", "All UV maps");
2745         rna_def_uv_textures(brna, prop);
2746
2747         prop = RNA_def_property(srna, "uv_texture_clone", PROP_POINTER, PROP_NONE);
2748         RNA_def_property_struct_type(prop, "MeshTexturePolyLayer");
2749         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_texture_clone_get",
2750                                        "rna_Mesh_uv_texture_clone_set", NULL, NULL);
2751         RNA_def_property_flag(prop, PROP_EDITABLE);
2752         RNA_def_property_ui_text(prop, "Clone UV Map", "UV map to be used as cloning source");
2753
2754         prop = RNA_def_property(srna, "uv_texture_clone_index", PROP_INT, PROP_UNSIGNED);
2755         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_texture_clone_index_get",
2756                                    "rna_Mesh_uv_texture_clone_index_set", "rna_Mesh_uv_texture_index_range");
2757         RNA_def_property_ui_text(prop, "Clone UV Map Index", "Clone UV map index");
2758
2759         prop = RNA_def_property(srna, "uv_texture_stencil", PROP_POINTER, PROP_NONE);
2760         RNA_def_property_struct_type(prop, "MeshTexturePolyLayer");
2761         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_texture_stencil_get",
2762                                        "rna_Mesh_uv_texture_stencil_set", NULL, NULL);
2763         RNA_def_property_flag(prop, PROP_EDITABLE);
2764         RNA_def_property_ui_text(prop, "Mask UV Map", "UV map to mask the painted area");
2765
2766         prop = RNA_def_property(srna, "uv_texture_stencil_index", PROP_INT, PROP_UNSIGNED);
2767         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_texture_stencil_index_get",
2768                                    "rna_Mesh_uv_texture_stencil_index_set", "rna_Mesh_uv_texture_index_range");
2769         RNA_def_property_ui_text(prop, "Mask UV Map Index", "Mask UV map index");
2770
2771         /* Tessellated face colors - used by renderers */
2772
2773         prop = RNA_def_property(srna, "tessface_vertex_colors", PROP_COLLECTION, PROP_NONE);
2774         RNA_def_property_collection_sdna(prop, NULL, "fdata.layers", "fdata.totlayer");
2775         RNA_def_property_collection_funcs(prop, "rna_Mesh_tessface_vertex_colors_begin", NULL, NULL, NULL,
2776                                           "rna_Mesh_tessface_vertex_colors_length", NULL, NULL, NULL);
2777         RNA_def_property_struct_type(prop, "MeshColorLayer");
2778         RNA_def_property_ui_text(prop, "Tessellated Face Colors",
2779                                  "All tessellated face colors (read-only, for use by renderers)");
2780         rna_def_tessface_vertex_colors(brna, prop);
2781
2782         /* Vertex colors */
2783
2784         prop = RNA_def_property(srna, "vertex_colors", PROP_COLLECTION, PROP_NONE);
2785         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
2786         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_colors_begin", NULL, NULL, NULL,
2787                                           "rna_Mesh_vertex_colors_length", NULL, NULL, NULL);
2788         RNA_def_property_struct_type(prop, "MeshLoopColorLayer");
2789         RNA_def_property_ui_text(prop, "Vertex Colors", "All vertex colors");
2790         rna_def_loop_colors(brna, prop);
2791
2792         prop = RNA_def_property(srna, "polygon_layers_float", PROP_COLLECTION, PROP_NONE);
2793         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2794         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_float_layers_begin", NULL, NULL, NULL,
2795                                           "rna_Mesh_polygon_float_layers_length", NULL, NULL, NULL);
2796         RNA_def_property_struct_type(prop, "MeshFloatPropertyLayer");
2797         RNA_def_property_ui_text(prop, "Float Property Layers", "");
2798         rna_def_polygon_float_layers(brna, prop);
2799
2800         prop = RNA_def_property(srna, "polygon_layers_int", PROP_COLLECTION, PROP_NONE);
2801         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2802         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_int_layers_begin", NULL, NULL, NULL,
2803                                           "rna_Mesh_polygon_int_layers_length", NULL, NULL, NULL);
2804         RNA_def_property_struct_type(prop, "MeshIntPropertyLayer");
2805         RNA_def_property_ui_text(prop, "Int Property Layers", "");
2806         rna_def_polygon_int_layers(brna, prop);
2807
2808         prop = RNA_def_property(srna, "polygon_layers_string", PROP_COLLECTION, PROP_NONE);
2809         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
2810         RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_string_layers_begin", NULL, NULL, NULL,
2811                                           "rna_Mesh_polygon_string_layers_length", NULL, NULL, NULL);
2812         RNA_def_property_struct_type(prop, "MeshStringPropertyLayer");
2813         RNA_def_property_ui_text(prop, "String Property Layers", "");
2814         rna_def_polygon_string_layers(brna, prop);
2815
2816         /* Skin vertices */
2817         prop = RNA_def_property(srna, "skin_vertices", PROP_COLLECTION, PROP_NONE);
2818         RNA_def_property_collection_sdna(prop, NULL, "vdata.layers", "vdata.totlayer");
2819         RNA_def_property_collection_funcs(prop, "rna_Mesh_skin_vertices_begin", NULL, NULL, NULL,
2820                                           "rna_Mesh_skin_vertices_length", NULL, NULL, NULL);
2821         RNA_def_property_struct_type(prop, "MeshSkinVertexLayer");
2822         RNA_def_property_ui_text(prop, "Skin Vertices", "All skin vertices");
2823         rna_def_skin_vertices(brna, prop);
2824         /* End skin vertices */
2825
2826         prop = RNA_def_property(srna, "use_auto_smooth", PROP_BOOLEAN, PROP_NONE);
2827         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_AUTOSMOOTH);
2828         RNA_def_property_ui_text(prop, "Auto Smooth",
2829                                  "Treat all set-smoothed faces with angles less than the specified angle "
2830                                  "as 'smooth' during render");
2831
2832 #if 1 /* expose as radians */
2833         prop = RNA_def_property(srna, "auto_smooth_angle", PROP_FLOAT, PROP_ANGLE);
2834         RNA_def_property_float_funcs(prop, "rna_Mesh_auto_smooth_angle_get", "rna_Mesh_auto_smooth_angle_set", NULL);
2835         RNA_def_property_ui_range(prop, DEG2RAD(1.0), DEG2RAD(80), 1.0, 1);
2836 #else
2837         prop = RNA_def_property(srna, "auto_smooth_angle", PROP_INT, PROP_NONE);
2838         RNA_def_property_int_sdna(prop, NULL, "smoothresh");
2839         RNA_def_property_range(prop, 1, 80);
2840 #endif
2841         RNA_def_property_ui_text(prop, "Auto Smooth Angle",
2842                                  "Maximum angle between face normals that 'Auto Smooth' will operate on");
2843
2844         prop = RNA_def_property(srna, "show_double_sided", PROP_BOOLEAN, PROP_NONE);
2845         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_TWOSIDED);
2846         RNA_def_property_ui_text(prop, "Double Sided", "Render/display the mesh with double or single sided lighting");
2847         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
2848
2849         prop = RNA_def_property(srna, "texco_mesh", PROP_POINTER, PROP_NONE);
2850         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
2851         RNA_def_property_flag(prop, PROP_EDITABLE);
2852         RNA_def_property_ui_text(prop, "Texture Space Mesh", "Derive texture coordinates from another mesh");
2853
2854         prop = RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
2855         RNA_def_property_pointer_sdna(prop, NULL, "key");
2856         RNA_def_property_ui_text(prop, "Shape Keys", "");
2857
2858         /* texture space */
2859         prop = RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
2860         RNA_def_property_boolean_sdna(prop, NULL, "texflag", ME_AUTOSPACE);
2861         RNA_def_property_ui_text(prop, "Auto Texture Space",
2862                                  "Adjust active object's texture space automatically when transforming object");
2863
2864 #if 0
2865         prop = RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
2866         RNA_def_property_array(prop, 3);
2867         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
2868         RNA_def_property_editable_func(prop, "rna_Mesh_texspace_editable");
2869         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_loc_get", "rna_Mesh_texspace_loc_set", NULL);
2870         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2871 #endif
2872
2873         /* not supported yet */
2874 #if 0
2875         prop = RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
2876         RNA_def_property_float(prop, NULL, "rot");
2877         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
2878         RNA_def_property_editable_func(prop, texspace_editable);
2879         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2880 #endif
2881
2882         /* Mesh Draw Options for Edit Mode*/
2883
2884         prop = RNA_def_property(srna, "show_edges", PROP_BOOLEAN, PROP_NONE);
2885         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEDGES);
2886         RNA_def_property_ui_text(prop, "Draw Edges",
2887                                  "Display selected edges using highlights in the 3D view and UV editor");
2888         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2889
2890         prop = RNA_def_property(srna, "show_all_edges", PROP_BOOLEAN, PROP_NONE);
2891         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_ALLEDGES);
2892         RNA_def_property_ui_text(prop, "All Edges", "Display all edges for wireframe in all view modes in the 3D view");
2893         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2894
2895         prop = RNA_def_property(srna, "show_faces", PROP_BOOLEAN, PROP_NONE);
2896         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWFACES);
2897         RNA_def_property_ui_text(prop, "Draw Faces", "Display all faces as shades in the 3D view and UV editor");
2898         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2899
2900         prop = RNA_def_property(srna, "show_normal_face", PROP_BOOLEAN, PROP_NONE);
2901         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWNORMALS);
2902         RNA_def_property_ui_text(prop, "Draw Normals", "Display face normals as lines");
2903         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2904
2905         prop = RNA_def_property(srna, "show_normal_vertex", PROP_BOOLEAN, PROP_NONE);
2906         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_VNORMALS);
2907         RNA_def_property_ui_text(prop, "Draw Vertex Normals", "Display vertex normals as lines");
2908         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2909
2910         prop = RNA_def_property(srna, "show_edge_crease", PROP_BOOLEAN, PROP_NONE);
2911         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWCREASES);
2912         RNA_def_property_ui_text(prop, "Draw Creases", "Display creases created for subsurf weighting");
2913         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2914
2915         prop = RNA_def_property(srna, "show_edge_bevel_weight", PROP_BOOLEAN, PROP_NONE);
2916         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWBWEIGHTS);
2917         RNA_def_property_ui_text(prop, "Draw Bevel Weights", "Display weights created for the Bevel modifier");
2918         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2919
2920         prop = RNA_def_property(srna, "show_edge_seams", PROP_BOOLEAN, PROP_NONE);
2921         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSEAMS);
2922         RNA_def_property_ui_text(prop, "Draw Seams", "Display UV unwrapping seams");
2923         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2924
2925         prop = RNA_def_property(srna, "show_edge_sharp", PROP_BOOLEAN, PROP_NONE);
2926         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSHARP);
2927         RNA_def_property_ui_text(prop, "Draw Sharp", "Display sharp edges, used with the EdgeSplit modifier");
2928         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2929
2930         prop = RNA_def_property(srna, "show_extra_edge_length", PROP_BOOLEAN, PROP_NONE);
2931         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_EDGELEN);
2932         RNA_def_property_ui_text(prop, "Edge Length",
2933                                  "Display selected edge lengths, using global values when set in the transform panel");
2934         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2935
2936         prop = RNA_def_property(srna, "show_extra_face_angle", PROP_BOOLEAN, PROP_NONE);
2937         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_FACEANG);
2938         RNA_def_property_ui_text(prop, "Face Angles",
2939                                  "Display the angles in the selected edges in degrees, "
2940                                  "using global values when set in the transform panel");
2941         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2942
2943         prop = RNA_def_property(srna, "show_extra_face_area", PROP_BOOLEAN, PROP_NONE);
2944         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_FACEAREA);
2945         RNA_def_property_ui_text(prop, "Face Area",
2946                                  "Display the area of selected faces, "
2947                                  "using global values when set in the transform panel");
2948         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2949
2950         prop = RNA_def_property(srna, "show_extra_indices", PROP_BOOLEAN, PROP_NONE);
2951         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_INDICES);
2952         RNA_def_property_ui_text(prop, "Indices", "Display the index numbers of selected vertices, edges, and faces");
2953         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2954
2955         /* editflag */
2956         prop = RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
2957         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_X);
2958         RNA_def_property_ui_text(prop, "X Mirror", "X Axis mirror editing");
2959
2960 #if 0
2961         prop = RNA_def_property(srna, "use_mirror_y", PROP_BOOLEAN, PROP_NONE);
2962         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Y);
2963         RNA_def_property_ui_text(prop, "Y Mirror", "Y Axis mirror editing");
2964
2965         prop = RNA_def_property(srna, "use_mirror_z", PROP_BOOLEAN, PROP_NONE);
2966         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Z);
2967         RNA_def_property_ui_text(prop, "Z Mirror", "Z Axis mirror editing");
2968 #endif
2969
2970         prop = RNA_def_property(srna, "use_mirror_topology", PROP_BOOLEAN, PROP_NONE);
2971         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_TOPO);
2972         RNA_def_property_ui_text(prop, "Topology Mirror",
2973                                  "Use topology based mirroring "
2974                                  "(for when both sides of mesh have matching, unique topology)");
2975
2976         prop = RNA_def_property(srna, "use_paint_mask", PROP_BOOLEAN, PROP_NONE);
2977         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_PAINT_MASK);
2978         RNA_def_property_ui_text(prop, "Paint Mask", "Face selection masking for painting");
2979         RNA_def_property_ui_icon(prop, ICON_FACESEL_HLT, 0);
2980         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Mesh_update_facemask");
2981
2982         prop = RNA_def_property(srna, "use_paint_mask_vertex", PROP_BOOLEAN, PROP_NONE);
2983         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_VERT_SEL);
2984         RNA_def_property_ui_text(prop, "Vertex Selection", "Vertex selection masking for painting (weight paint only)");
2985         RNA_def_property_ui_icon(prop, ICON_VERTEXSEL, 0);
2986         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Mesh_update_vertmask");
2987
2988         /* readonly editmesh info - use for extrude menu */
2989         prop = RNA_def_property(srna, "total_vert_sel", PROP_INT, PROP_UNSIGNED);
2990         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_vert_get", NULL, NULL);
2991         RNA_def_property_ui_text(prop, "Selected Vert Total", "Selected vertex count in editmode");
2992         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2993
2994         prop = RNA_def_property(srna, "total_edge_sel", PROP_INT, PROP_UNSIGNED);
2995         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_edge_get", NULL, NULL);
2996         RNA_def_property_ui_text(prop, "Selected Edge Total", "Selected edge count in editmode");
2997         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2998
2999         prop = RNA_def_property(srna, "total_face_sel", PROP_INT, PROP_UNSIGNED);
3000         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_face_get", NULL, NULL);
3001         RNA_def_property_ui_text(prop, "Selected Face Total", "Selected face count in editmode");
3002         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3003
3004         /* pointers */
3005         rna_def_animdata_common(srna);
3006         rna_def_texmat_common(srna, "rna_Mesh_texspace_editable");
3007
3008         RNA_api_mesh(srna);
3009 }
3010
3011 void RNA_def_mesh(BlenderRNA *brna)
3012 {
3013         rna_def_mesh(brna);
3014         rna_def_mvert(brna);
3015         rna_def_mvert_group(brna);
3016         rna_def_medge(brna);
3017         rna_def_mface(brna);
3018         rna_def_mloop(brna);
3019         rna_def_mpolygon(brna);
3020         rna_def_mloopuv(brna);
3021         rna_def_mtface(brna);
3022         rna_def_mtexpoly(brna);
3023         rna_def_mcol(brna);
3024         rna_def_mloopcol(brna);
3025         rna_def_mproperties(brna);
3026 }
3027
3028 #endif