svn merge ^/trunk/blender -r40720:40872
[blender.git] / source / blender / makesrna / intern / rna_mesh.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Blender Foundation (2008).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /*note: the original vertex color stuff is now just used for
26   getting info on the layers themselves, accessing the data is
27   done through the (not yet written) mpoly interfaces.*/
28
29 /** \file blender/makesrna/intern/rna_mesh.c
30  *  \ingroup RNA
31  */
32
33
34 #include <stdlib.h>
35
36 #include "RNA_define.h"
37 #include "RNA_types.h"
38
39 #include "rna_internal.h"
40
41 #include "DNA_material_types.h"
42 #include "DNA_mesh_types.h"
43 #include "DNA_meshdata_types.h"
44 #include "DNA_object_types.h"
45
46 #include "WM_types.h"
47
48 #include "BLI_math_base.h"
49 #include "BLI_math_rotation.h"
50
51 #ifdef RNA_RUNTIME
52
53 #include "DNA_scene_types.h"
54
55 #include "BLI_editVert.h"
56 #include "BLI_math.h"
57
58 #include "BKE_customdata.h"
59 #include "BKE_depsgraph.h"
60 #include "BKE_main.h"
61 #include "BKE_mesh.h"
62 #include "BKE_tessmesh.h"
63
64 #include "ED_mesh.h" /* XXX Bad level call */
65
66 #include "WM_api.h"
67 #include "WM_types.h"
68
69 static void rna_Mesh_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
70 {
71         ID *id= ptr->id.data;
72
73         /* cheating way for importers to avoid slow updates */
74         if(id->us > 0) {
75                 DAG_id_tag_update(id, 0);
76                 WM_main_add_notifier(NC_GEOM|ND_DATA, id);
77         }
78 }
79
80 static void rna_Mesh_update_select(Main *bmain, Scene *scene, PointerRNA *ptr)
81 {
82         ID *id= ptr->id.data;
83         /* cheating way for importers to avoid slow updates */
84         if(id->us > 0) {
85                 WM_main_add_notifier(NC_GEOM|ND_SELECT, id);
86         }
87 }
88
89 void rna_Mesh_update_draw(Main *bmain, Scene *scene, PointerRNA *ptr)
90 {
91         ID *id= ptr->id.data;
92         /* cheating way for importers to avoid slow updates */
93         if(id->us > 0) {
94                 WM_main_add_notifier(NC_GEOM|ND_DATA, id);
95         }
96 }
97
98
99 void rna_Mesh_update_vertmask(Main *bmain, Scene *scene, PointerRNA *ptr)
100 {
101         Mesh* me = ptr->data;
102         if ((me->editflag & ME_EDIT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_MASK)) {
103                 me->editflag ^= ME_EDIT_PAINT_MASK;
104         }
105         rna_Mesh_update_draw(bmain, scene, ptr);
106 }
107
108 void rna_Mesh_update_facemask(Main *bmain, Scene *scene, PointerRNA *ptr)
109 {
110         Mesh* me = ptr->data;
111         if ((me->editflag & ME_EDIT_VERT_SEL) && (me->editflag & ME_EDIT_PAINT_MASK)) {
112                 me->editflag ^= ME_EDIT_VERT_SEL;
113         }
114         rna_Mesh_update_draw(bmain, scene, ptr);
115 }
116 static void rna_MeshVertex_normal_get(PointerRNA *ptr, float *value)
117 {
118         MVert *mvert= (MVert*)ptr->data;
119         normal_short_to_float_v3(value, mvert->no);
120 }
121
122 static void rna_MeshVertex_normal_set(PointerRNA *ptr, const float *value)
123 {
124         MVert *mvert= (MVert*)ptr->data;
125         float no[3];
126
127         copy_v3_v3(no, value);
128         normalize_v3(no);
129         normal_float_to_short_v3(mvert->no, no);
130 }
131
132 static float rna_MeshVertex_bevel_weight_get(PointerRNA *ptr)
133 {
134         MVert *mvert= (MVert*)ptr->data;
135         return mvert->bweight/255.0f;
136 }
137
138 static void rna_MeshVertex_bevel_weight_set(PointerRNA *ptr, float value)
139 {
140         MVert *mvert= (MVert*)ptr->data;
141         mvert->bweight= (char)(CLAMPIS(value*255.0f, 0, 255));
142 }
143
144 static float rna_MEdge_bevel_weight_get(PointerRNA *ptr)
145 {
146         MEdge *medge= (MEdge*)ptr->data;
147         return medge->bweight/255.0f;
148 }
149
150 static void rna_MEdge_bevel_weight_set(PointerRNA *ptr, float value)
151 {
152         MEdge *medge= (MEdge*)ptr->data;
153         medge->bweight= (char)(CLAMPIS(value*255.0f, 0, 255));
154 }
155
156 static float rna_MEdge_crease_get(PointerRNA *ptr)
157 {
158         MEdge *medge= (MEdge*)ptr->data;
159         return medge->crease/255.0f;
160 }
161
162 static void rna_MEdge_crease_set(PointerRNA *ptr, float value)
163 {
164         MEdge *medge= (MEdge*)ptr->data;
165         medge->crease= (char)(CLAMPIS(value*255.0f, 0, 255));
166 }
167
168 static void rna_MeshPolygon_normal_get(PointerRNA *ptr, float *values)
169 {
170         Mesh *me= (Mesh*)ptr->id.data;
171         MPoly *mp= (MPoly*)ptr->data;
172
173         mesh_calc_poly_normal(mp, me->mloop+mp->loopstart, me->mvert, values);
174 }
175
176 static void rna_MeshFace_normal_get(PointerRNA *ptr, float *values)
177 {
178         Mesh *me= (Mesh*)ptr->id.data;
179         MFace *mface= (MFace*)ptr->data;
180
181         if(mface->v4)
182                 normal_quad_v3( values,me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co, me->mvert[mface->v4].co);
183         else
184                 normal_tri_v3( values,me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co);
185 }
186
187 static float rna_MeshFace_area_get(PointerRNA *ptr)
188 {
189         Mesh *me= (Mesh*)ptr->id.data;
190         MFace *mface= (MFace*)ptr->data;
191
192         if(mface->v4)
193                 return area_quad_v3(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co, me->mvert[mface->v4].co);
194         else
195                 return area_tri_v3(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co);
196 }
197
198 /* notice red and blue are swapped */
199 static void rna_MeshColor_color1_get(PointerRNA *ptr, float *values)
200 {
201         MCol *mcol= (MCol*)ptr->data;
202
203         values[2]= (&mcol[0].r)[0]/255.0f;
204         values[1]= (&mcol[0].r)[1]/255.0f;
205         values[0]= (&mcol[0].r)[2]/255.0f;
206 }
207
208 static void rna_MeshColor_color1_set(PointerRNA *ptr, const float *values)
209 {
210         MCol *mcol= (MCol*)ptr->data;
211
212         (&mcol[0].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
213         (&mcol[0].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
214         (&mcol[0].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
215 }
216
217 static void rna_MeshColor_color2_get(PointerRNA *ptr, float *values)
218 {
219         MCol *mcol= (MCol*)ptr->data;
220
221         values[2]= (&mcol[1].r)[0]/255.0f;
222         values[1]= (&mcol[1].r)[1]/255.0f;
223         values[0]= (&mcol[1].r)[2]/255.0f;
224 }
225
226 static void rna_MeshColor_color2_set(PointerRNA *ptr, const float *values)
227 {
228         MCol *mcol= (MCol*)ptr->data;
229
230         (&mcol[1].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
231         (&mcol[1].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
232         (&mcol[1].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
233 }
234
235 static void rna_MeshColor_color3_get(PointerRNA *ptr, float *values)
236 {
237         MCol *mcol= (MCol*)ptr->data;
238
239         values[2]= (&mcol[2].r)[0]/255.0f;
240         values[1]= (&mcol[2].r)[1]/255.0f;
241         values[0]= (&mcol[2].r)[2]/255.0f;
242 }
243
244 static void rna_MeshColor_color3_set(PointerRNA *ptr, const float *values)
245 {
246         MCol *mcol= (MCol*)ptr->data;
247
248         (&mcol[2].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
249         (&mcol[2].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
250         (&mcol[2].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
251 }
252
253 static void rna_MeshColor_color4_get(PointerRNA *ptr, float *values)
254 {
255         MCol *mcol= (MCol*)ptr->data;
256
257         values[2]= (&mcol[3].r)[0]/255.0f;
258         values[1]= (&mcol[3].r)[1]/255.0f;
259         values[0]= (&mcol[3].r)[2]/255.0f;
260 }
261
262 static void rna_MeshColor_color4_set(PointerRNA *ptr, const float *values)
263 {
264         MCol *mcol= (MCol*)ptr->data;
265
266         (&mcol[3].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
267         (&mcol[3].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
268         (&mcol[3].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
269 }
270
271 static int rna_Mesh_texspace_editable(PointerRNA *ptr)
272 {
273         Mesh *me= (Mesh*)ptr->data;
274         return (me->texflag & AUTOSPACE)? 0: PROP_EDITABLE;
275 }
276
277 static void rna_MeshVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
278 {
279         Mesh *me= (Mesh*)ptr->id.data;
280
281         if(me->dvert) {
282                 MVert *mvert= (MVert*)ptr->data;
283                 MDeformVert *dvert= me->dvert + (mvert-me->mvert);
284
285                 rna_iterator_array_begin(iter, (void*)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
286         }
287         else
288                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
289 }
290
291 static void rna_MeshFace_material_index_range(PointerRNA *ptr, int *min, int *max)
292 {
293         Mesh *me= (Mesh*)ptr->id.data;
294         *min= 0;
295         *max= me->totcol-1;
296         *max= MAX2(0, *max);
297 }
298
299 static CustomData *rna_mesh_pdata(Mesh *me)
300 {
301         return (me->edit_btmesh)? &me->edit_btmesh->bm->pdata: &me->pdata;
302 }
303
304 static CustomData *rna_mesh_ldata(Mesh *me)
305 {
306         return (me->edit_btmesh)? &me->edit_btmesh->bm->ldata: &me->ldata;
307 }
308
309 static int rna_CustomDataLayer_length(PointerRNA *ptr, int type)
310 {
311         Mesh *me= (Mesh*)ptr->id.data;
312         CustomData *fdata= rna_mesh_pdata(me);
313         CustomDataLayer *layer;
314         int i, length= 0;
315
316         for(layer=fdata->layers, i=0; i<fdata->totlayer; layer++, i++)
317                 if(layer->type == type)
318                         length++;
319
320         return length;
321 }
322
323 static int rna_CustomDataLayer_active_get(PointerRNA *ptr, int type, int render)
324 {
325         Mesh *me= (Mesh*)ptr->id.data;
326         CustomData *fdata= rna_mesh_pdata(me);
327         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
328
329         if(render) return (n == CustomData_get_render_layer_index(fdata, type));
330         else return (n == CustomData_get_active_layer_index(fdata, type));
331 }
332
333 static int rna_CustomDataLayer_clone_get(PointerRNA *ptr, int type, int render)
334 {
335         Mesh *me= (Mesh*)ptr->id.data;
336         CustomData *fdata= rna_mesh_pdata(me);
337         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
338
339         return (n == CustomData_get_clone_layer_index(fdata, type));
340 }
341
342 static void rna_CustomDataLayer_active_set(PointerRNA *ptr, int value, int type, int render)
343 {
344         Mesh *me= (Mesh*)ptr->id.data;
345         CustomData *fdata= rna_mesh_pdata(me);
346         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
347
348         if(value == 0)
349                 return;
350
351         if(render) CustomData_set_layer_render_index(fdata, type, n);
352         else CustomData_set_layer_active_index(fdata, type, n);
353 }
354
355 static void rna_CustomDataLayer_clone_set(PointerRNA *ptr, int value, int type, int render)
356 {
357         Mesh *me= (Mesh*)ptr->id.data;
358         CustomData *fdata= rna_mesh_pdata(me);
359         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
360
361         if(value == 0)
362                 return;
363
364         CustomData_set_layer_clone_index(fdata, type, n);
365 }
366
367 static int rna_uv_texture_check(CollectionPropertyIterator *iter, void *data)
368 {
369         CustomDataLayer *layer= (CustomDataLayer*)data;
370         return (layer->type != CD_MTEXPOLY);
371 }
372
373 static void rna_Mesh_uv_textures_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
374 {
375         Mesh *me= (Mesh*)ptr->data;
376         CustomData *fdata= rna_mesh_pdata(me);
377         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_uv_texture_check);
378 }
379
380 static int rna_Mesh_uv_textures_length(PointerRNA *ptr)
381 {
382         return rna_CustomDataLayer_length(ptr, CD_MTEXPOLY);
383 }
384
385 static PointerRNA rna_Mesh_active_uv_texture_get(PointerRNA *ptr)
386 {
387         Mesh *me= (Mesh*)ptr->data;
388         CustomData *fdata= rna_mesh_pdata(me);
389         int index= CustomData_get_active_layer_index(fdata, CD_MTEXPOLY);
390         CustomDataLayer *cdl= (index == -1)? NULL: &fdata->layers[index];
391
392         return rna_pointer_inherit_refine(ptr, &RNA_MeshTextureFaceLayer, cdl);
393 }
394
395 static PointerRNA rna_Mesh_uv_texture_clone_get(PointerRNA *ptr)
396 {
397         PointerRNA pnull = {{0}};
398 #if 0
399         Mesh *me= (Mesh*)ptr->data;
400         CustomData *fdata= rna_mesh_fdata(me);
401         int index= CustomData_get_clone_layer_index(fdata, CD_MTFACE);
402         CustomDataLayer *cdl= (index == -1)? NULL: &fdata->layers[index];
403
404         return rna_pointer_inherit_refine(ptr, &RNA_MeshTextureFaceLayer, cdl);
405 #endif
406         return pnull;
407 }
408
409 static PointerRNA rna_Mesh_uv_texture_stencil_get(PointerRNA *ptr)
410 {
411         PointerRNA pnull = {{0}};
412 #if 0
413         Mesh *me= (Mesh*)ptr->data;
414         CustomData *fdata= rna_mesh_fdata(me);
415         int index= CustomData_get_stencil_layer_index(fdata, CD_MTFACE);
416         CustomDataLayer *cdl= (index == -1)? NULL: &fdata->layers[index];
417
418         return rna_pointer_inherit_refine(ptr, &RNA_MeshTextureFaceLayer, cdl);
419 #endif
420         return pnull;
421 }
422
423 static void rna_Mesh_active_uv_texture_set(PointerRNA *ptr, PointerRNA value)
424 {
425         Mesh *me= (Mesh*)ptr->data;
426         CustomData *fdata= rna_mesh_pdata(me);
427         CustomDataLayer *cdl;
428         int a;
429
430         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
431                 if(value.data == cdl) {
432                         CustomData_set_layer_active_index(fdata, CD_MTEXPOLY, a);
433                         mesh_update_customdata_pointers(me);
434                         return;
435                 }
436         }
437 }
438
439 static void rna_Mesh_uv_texture_clone_set(PointerRNA *ptr, PointerRNA value)
440 {
441 #if 0
442         Mesh *me= (Mesh*)ptr->data;
443         CustomData *fdata= rna_mesh_fdata(me);
444         CustomDataLayer *cdl;
445         int a;
446
447         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
448                 if(value.data == cdl) {
449                         CustomData_set_layer_clone_index(fdata, CD_MTFACE, a);
450                         return;
451                 }
452         }
453 #endif
454         return;
455 }
456
457 static void rna_Mesh_uv_texture_stencil_set(PointerRNA *ptr, PointerRNA value)
458 {
459 #if 0
460         Mesh *me= (Mesh*)ptr->data;
461         CustomData *fdata= rna_mesh_fdata(me);
462         CustomDataLayer *cdl;
463         int a;
464
465         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
466                 if(value.data == cdl) {
467                         CustomData_set_layer_stencil_index(fdata, CD_MTFACE, a);
468                         return;
469                 }
470         }
471 #endif
472         return;
473 }
474
475 static int rna_Mesh_active_uv_texture_index_get(PointerRNA *ptr)
476 {
477         Mesh *me= (Mesh*)ptr->data;
478         CustomData *fdata= rna_mesh_pdata(me);
479         return CustomData_get_active_layer(fdata, CD_MTEXPOLY);
480 }
481
482 static int rna_Mesh_uv_texture_clone_index_get(PointerRNA *ptr)
483 {
484         Mesh *me= (Mesh*)ptr->data;
485         CustomData *fdata= rna_mesh_pdata(me);
486         return CustomData_get_clone_layer(fdata, CD_MTEXPOLY);
487 }
488
489 static int rna_Mesh_uv_texture_stencil_index_get(PointerRNA *ptr)
490 {
491         Mesh *me= (Mesh*)ptr->data;
492         CustomData *fdata= rna_mesh_pdata(me);
493         return CustomData_get_stencil_layer(fdata, CD_MTEXPOLY);
494 }
495
496 static void rna_Mesh_active_uv_texture_index_set(PointerRNA *ptr, int value)
497 {
498         Mesh *me= (Mesh*)ptr->data;
499         CustomData *fdata= rna_mesh_pdata(me);
500
501         CustomData_set_layer_active(fdata, CD_MTEXPOLY, value);
502         mesh_update_customdata_pointers(me);
503 }
504
505 static void rna_Mesh_uv_texture_clone_index_set(PointerRNA *ptr, int value)
506 {
507         Mesh *me= (Mesh*)ptr->data;
508         CustomData *fdata= rna_mesh_pdata(me);
509
510         CustomData_set_layer_clone(fdata, CD_MTEXPOLY, value);
511 }
512
513 static void rna_Mesh_uv_texture_stencil_index_set(PointerRNA *ptr, int value)
514 {
515         Mesh *me= (Mesh*)ptr->data;
516         CustomData *fdata= rna_mesh_pdata(me);
517
518         CustomData_set_layer_stencil(fdata, CD_MTEXPOLY, value);
519 }
520
521 static void rna_Mesh_active_uv_texture_index_range(PointerRNA *ptr, int *min, int *max)
522 {
523         Mesh *me= (Mesh*)ptr->data;
524         CustomData *pdata= rna_mesh_pdata(me);
525
526         *min= 0;
527         *max= CustomData_number_of_layers(pdata, CD_MTEXPOLY)-1;
528         *max= MAX2(0, *max);
529 }
530
531 static void rna_MeshTextureFace_uv1_get(PointerRNA *ptr, float *values)
532 {
533         MLoopUV *mloopuv= (MLoopUV*)ptr->data;
534         
535         values[0]= mloopuv->uv[0];
536         values[1]= mloopuv->uv[1];
537 }
538
539 static void rna_MeshTextureFace_uv1_set(PointerRNA *ptr, const float *values)
540 {
541         MLoopUV *mloopuv= (MLoopUV*)ptr->data;
542         
543         mloopuv->uv[0] = values[0];
544         mloopuv->uv[1] = values[1];
545 }
546
547 static int rna_CustomDataData_numverts(PointerRNA *ptr, int type)
548 {
549         /*BMESH_TODO
550         Mesh *me= (Mesh*)ptr->id.data;
551         CustomData *fdata= rna_mesh_fdata(me);
552         CustomDataLayer *cdl;
553         int a, b;
554
555         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
556                 if(cdl->type == type) {
557                         b= ((char*)ptr->data - ((char*)cdl->data))/CustomData_sizeof(type);
558                         if(b >= 0 && b < me->totface)
559                                 return (me->mface[b].v4? 4: 3);
560                 }
561         }
562
563         return 0;*/
564         return 0;
565 }
566
567 static int rna_MeshTextureFace_uv_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
568 {
569         //return rna_CustomDataData_numverts(ptr, CD_MTFACE) * 2;
570         return 0; //BMESH_TODO
571 }
572
573 static void rna_MeshTextureFace_uv_get(PointerRNA *ptr, float *values)
574 {
575         //MTFace *mtface= (MTFace*)ptr->data;
576         //int totvert= rna_CustomDataData_numverts(ptr, CD_MTFACE);
577
578         //memcpy(values, mtface->uv, totvert * 2 * sizeof(float));
579 }
580
581 static void rna_MeshTextureFace_uv_set(PointerRNA *ptr, const float *values)
582 {
583         //MTFace *mtface= (MTFace*)ptr->data;
584         //int totvert= rna_CustomDataData_numverts(ptr, CD_MTFACE);
585
586         //memcpy(mtface->uv, values, totvert * 2 * sizeof(float));
587 }
588
589 static void rna_MeshTextureFaceLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
590 {
591         Mesh *me= (Mesh*)ptr->id.data;
592         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
593         rna_iterator_array_begin(iter, layer->data, sizeof(MTexPoly), me->totpoly, 0, NULL);
594 }
595
596 static int rna_MeshTextureFaceLayer_data_length(PointerRNA *ptr)
597 {
598         Mesh *me= (Mesh*)ptr->id.data;
599         return me->totpoly;
600 }
601
602 static int rna_MeshTextureFaceLayer_active_render_get(PointerRNA *ptr)
603 {
604         return rna_CustomDataLayer_active_get(ptr, CD_MTEXPOLY, 1);
605 }
606
607 static int rna_MeshTextureFaceLayer_active_get(PointerRNA *ptr)
608 {
609         return rna_CustomDataLayer_active_get(ptr, CD_MTEXPOLY, 0);
610 }
611
612 static int rna_MeshTextureFaceLayer_clone_get(PointerRNA *ptr)
613 {
614         return rna_CustomDataLayer_clone_get(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, value, CD_MTEXPOLY, 1);
620 }
621
622 static void rna_MeshTextureFaceLayer_active_set(PointerRNA *ptr, int value)
623 {
624         rna_CustomDataLayer_active_set(ptr, value, CD_MTEXPOLY, 0);
625 }
626
627 static void rna_MeshTextureFaceLayer_clone_set(PointerRNA *ptr, int value)
628 {
629         rna_CustomDataLayer_clone_set(ptr, value, CD_MTFACE, 0);
630 }
631
632 static void rna_MeshTextureFaceLayer_name_set(PointerRNA *ptr, const char *value)
633 {
634         Mesh *me= (Mesh*)ptr->id.data;
635         /* CustomData *fdata= rna_mesh_pdata(me); */ /* UNUSED */
636         CustomDataLayer *cdl= (CustomDataLayer*)ptr->data;
637         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
638         CustomData_set_layer_unique_name(&me->pdata, cdl - rna_mesh_pdata(me)->layers);
639 }
640
641 static int rna_vertex_color_check(CollectionPropertyIterator *iter, void *data)
642 {
643         CustomDataLayer *layer= (CustomDataLayer*)data;
644         return (layer->type != CD_MLOOPCOL);
645 }
646
647 static void rna_Mesh_vertex_colors_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
648 {
649         Mesh *me= (Mesh*)ptr->data;
650         CustomData *ldata= rna_mesh_ldata(me);
651         rna_iterator_array_begin(iter, (void*)ldata->layers, sizeof(CustomDataLayer), ldata->totlayer, 0, rna_vertex_color_check);
652 }
653
654 static int rna_Mesh_vertex_colors_length(PointerRNA *ptr)
655 {
656         return rna_CustomDataLayer_length(ptr, CD_MLOOPCOL);
657 }
658
659 static PointerRNA rna_Mesh_active_vertex_color_get(PointerRNA *ptr)
660 {
661         Mesh *me= (Mesh*)ptr->data;
662         CustomData *ldata= rna_mesh_ldata(me);
663         int index= CustomData_get_active_layer_index(ldata, CD_MLOOPCOL);
664         CustomDataLayer *cdl= (index == -1)? NULL: &ldata->layers[index];
665
666         return rna_pointer_inherit_refine(ptr, &RNA_MeshColorLayer, cdl);
667 }
668
669 static void rna_Mesh_active_vertex_color_set(PointerRNA *ptr, PointerRNA value)
670 {
671         Mesh *me= (Mesh*)ptr->data;
672         CustomData *ldata= rna_mesh_ldata(me);
673         CustomDataLayer *cdl;
674         int a, b;
675
676         b = 0;
677         for(cdl=ldata->layers, a=0; a<ldata->totlayer; cdl++, a++) {
678                 if (cdl->type == CD_MLOOPCOL)
679                         b++;
680
681                 if(value.data == cdl) {
682                         CustomData_set_layer_active_index(ldata, CD_MLOOPCOL, a);
683                         break;
684                 }
685         }
686
687         mesh_update_customdata_pointers(me);
688 }
689
690 static int rna_Mesh_active_vertex_color_index_get(PointerRNA *ptr)
691 {
692         Mesh *me= (Mesh*)ptr->data;
693         CustomData *ldata= rna_mesh_ldata(me);
694         return CustomData_get_active_layer(ldata, CD_MLOOPCOL);
695 }
696
697 static void rna_Mesh_active_vertex_color_index_set(PointerRNA *ptr, int value)
698 {
699         Mesh *me= (Mesh*)ptr->data;
700         CustomData *ldata= rna_mesh_ldata(me);
701
702         CustomData_set_layer_active(ldata, CD_MLOOPCOL, value);
703         mesh_update_customdata_pointers(me);
704 }
705
706 static void rna_Mesh_active_vertex_color_index_range(PointerRNA *ptr, int *min, int *max)
707 {
708         Mesh *me= (Mesh*)ptr->data;
709         CustomData *ldata= rna_mesh_ldata(me);
710
711         *min= 0;
712         *max= CustomData_number_of_layers(ldata, CD_MLOOPCOL)-1;
713         *max= MAX2(0, *max);
714 }
715
716 static void rna_MeshColorLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
717 {
718         Mesh *me= (Mesh*)ptr->id.data;
719         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
720         rna_iterator_array_begin(iter, layer->data, sizeof(CD_MLOOPCOL), me->totloop, 0, NULL);
721 }
722
723 static int rna_MeshColorLayer_data_length(PointerRNA *ptr)
724 {
725         Mesh *me= (Mesh*)ptr->id.data;
726         return me->totloop;
727 }
728
729 static int rna_MeshColorLayer_active_render_get(PointerRNA *ptr)
730 {
731         return rna_CustomDataLayer_active_get(ptr, CD_MLOOPCOL, 1);
732 }
733
734 static int rna_MeshColorLayer_active_get(PointerRNA *ptr)
735 {
736         return rna_CustomDataLayer_active_get(ptr, CD_MLOOPCOL, 0);
737 }
738
739 static void rna_MeshColorLayer_active_render_set(PointerRNA *ptr, int value)
740 {
741         rna_CustomDataLayer_active_set(ptr, value, CD_MLOOPCOL, 1);
742 }
743
744 static void rna_MeshColorLayer_active_set(PointerRNA *ptr, int value)
745 {
746         rna_CustomDataLayer_active_set(ptr, value, CD_MLOOPCOL, 0);
747 }
748
749 static void rna_MeshColorLayer_name_set(PointerRNA *ptr, const char *value)
750 {
751         Mesh *me= (Mesh*)ptr->id.data;
752         /* CustomData *fdata= rna_mesh_pdata(me); */ /* UNUSED */
753         CustomDataLayer *cdl= (CustomDataLayer*)ptr->data;
754         BLI_strncpy_utf8(cdl->name, value, sizeof(cdl->name));
755         CustomData_set_layer_unique_name(&me->ldata, cdl - rna_mesh_ldata(me)->layers);
756 }
757
758 static void rna_MeshFloatPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
759 {
760         Mesh *me= (Mesh*)ptr->id.data;
761         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
762         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totface, 0, NULL);
763 }
764
765 static int rna_MeshFloatPropertyLayer_data_length(PointerRNA *ptr)
766 {
767         Mesh *me= (Mesh*)ptr->id.data;
768         return me->totface;
769 }
770
771 static int rna_float_layer_check(CollectionPropertyIterator *iter, void *data)
772 {
773         CustomDataLayer *layer= (CustomDataLayer*)data;
774         return (layer->type != CD_PROP_FLT);
775 }
776
777 static void rna_Mesh_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
778 {
779         Mesh *me= (Mesh*)ptr->data;
780         CustomData *fdata= rna_mesh_pdata(me);
781         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_float_layer_check);
782 }
783
784 static int rna_Mesh_float_layers_length(PointerRNA *ptr)
785 {
786         return rna_CustomDataLayer_length(ptr, CD_PROP_FLT);
787 }
788
789 static int rna_int_layer_check(CollectionPropertyIterator *iter, void *data)
790 {
791         CustomDataLayer *layer= (CustomDataLayer*)data;
792         return (layer->type != CD_PROP_INT);
793 }
794
795 static void rna_MeshIntPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
796 {
797         Mesh *me= (Mesh*)ptr->id.data;
798         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
799         rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totface, 0, NULL);
800 }
801
802 static int rna_MeshIntPropertyLayer_data_length(PointerRNA *ptr)
803 {
804         Mesh *me= (Mesh*)ptr->id.data;
805         return me->totface;
806 }
807
808 static void rna_Mesh_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
809 {
810         Mesh *me= (Mesh*)ptr->data;
811         CustomData *fdata= rna_mesh_pdata(me);
812         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_int_layer_check);
813 }
814
815 static int rna_Mesh_int_layers_length(PointerRNA *ptr)
816 {
817         return rna_CustomDataLayer_length(ptr, CD_PROP_INT);
818 }
819
820 static int rna_string_layer_check(CollectionPropertyIterator *iter, void *data)
821 {
822         CustomDataLayer *layer= (CustomDataLayer*)data;
823         return (layer->type != CD_PROP_STR);
824 }
825
826 static void rna_MeshStringPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
827 {
828         Mesh *me= (Mesh*)ptr->id.data;
829         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
830         rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totface, 0, NULL);
831 }
832
833 static int rna_MeshStringPropertyLayer_data_length(PointerRNA *ptr)
834 {
835         Mesh *me= (Mesh*)ptr->id.data;
836         return me->totface;
837 }
838
839 static void rna_Mesh_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
840 {
841         Mesh *me= (Mesh*)ptr->data;
842         CustomData *fdata= rna_mesh_pdata(me);
843         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_string_layer_check);
844 }
845
846 static int rna_Mesh_string_layers_length(PointerRNA *ptr)
847 {
848         return rna_CustomDataLayer_length(ptr, CD_PROP_STR);
849 }
850
851 static void rna_TextureFace_image_set(PointerRNA *ptr, PointerRNA value)
852 {
853         MTexPoly *tf= (MTexPoly*)ptr->data;
854         ID *id= value.data;
855
856         if(id) {
857                 /* special exception here, individual faces don't count
858                  * as reference, but we do ensure the refcount is not zero */
859                 if(id->us == 0)
860                         id_us_plus(id);
861                 else
862                         id_lib_extern(id);
863         }
864
865         tf->tpage= (struct Image*)id;
866 }
867
868 static void rna_Mesh_auto_smooth_angle_set(PointerRNA *ptr, float value)
869 {
870         Mesh *me= (Mesh*)ptr->id.data;
871         value= RAD2DEGF(value);
872         CLAMP(value, 1.0f, 80.0f);
873         me->smoothresh= (int)value;
874 }
875
876 static float rna_Mesh_auto_smooth_angle_get(PointerRNA *ptr)
877 {
878         Mesh *me= (Mesh*)ptr->id.data;
879         return DEG2RADF((float)me->smoothresh);
880 }
881
882 static int rna_MeshFace_verts_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
883 {
884         MFace *face= (MFace*)ptr->data;
885
886         if(face)
887                 length[0]= (face->v4)? 4: 3;
888         else
889                 length[0]= 4; // XXX rna_raw_access wants the length of a dummy face. this needs fixing. - Campbell
890
891         return length[0];
892 }
893
894 static void rna_MeshFace_verts_get(PointerRNA *ptr, int *values)
895 {
896         MFace *face= (MFace*)ptr->data;
897         memcpy(values, &face->v1, (face->v4 ? 4 : 3) * sizeof(int));
898 }
899
900 static void rna_MeshFace_verts_set(PointerRNA *ptr, const int *values)
901 {
902         MFace *face= (MFace*)ptr->data;
903         memcpy(&face->v1, values, (face->v4 ? 4 : 3) * sizeof(int));
904 }
905
906 /* poly.vertices - this is faked loop access for convenience */
907 static int rna_MeshPoly_vertices_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
908 {
909         MPoly *mp= (MPoly*)ptr->data;
910         /* note, raw access uses dummy item, this _could_ crash, watch out for this, mface uses it but it cant work here */
911         return (length[0]= mp->totloop);
912 }
913
914 static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
915 {
916         Mesh *me= (Mesh*)ptr->id.data;
917         MPoly *mp= (MPoly*)ptr->data;
918         MLoop *ml= &me->mloop[mp->loopstart];
919         unsigned int i;
920         for(i= mp->totloop; i > 0; i--, values++, ml++) {
921                 *values = ml->v;
922         }
923 }
924
925 static void rna_MeshPoly_vertices_set(PointerRNA *ptr, const int *values)
926 {
927         Mesh *me= (Mesh*)ptr->id.data;
928         MPoly *mp= (MPoly*)ptr->data;
929         MLoop *ml= &me->mloop[mp->loopstart];
930         unsigned int i;
931         for(i= mp->totloop; i > 0; i--, values++, ml++) {
932                 ml->v = *values;
933         }
934 }
935
936
937 static int rna_MeshVertex_index_get(PointerRNA *ptr)
938 {
939         Mesh *me= (Mesh*)ptr->id.data;
940         MVert *vert= (MVert*)ptr->data;
941         return (int)(vert - me->mvert);
942 }
943
944 static int rna_MeshEdge_index_get(PointerRNA *ptr)
945 {
946         Mesh *me= (Mesh*)ptr->id.data;
947         MEdge *edge= (MEdge*)ptr->data;
948         return (int)(edge - me->medge);
949 }
950
951 static int rna_MeshFace_index_get(PointerRNA *ptr)
952 {
953         Mesh *me= (Mesh*)ptr->id.data;
954         MFace *face= (MFace*)ptr->data;
955         return (int)(face - me->mface);
956 }
957
958 static int rna_MeshPolygon_index_get(PointerRNA *ptr)
959 {
960         Mesh *me= (Mesh*)ptr->id.data;
961         MPoly *mpoly= (MPoly*)ptr->data;
962         return (int)(mpoly - me->mpoly);
963 }
964
965 /* path construction */
966
967 static char *rna_VertexGroupElement_path(PointerRNA *ptr)
968 {
969         Mesh *me= (Mesh*)ptr->id.data; /* XXX not always! */
970         MDeformWeight *dw= (MDeformWeight*)ptr->data;
971         MDeformVert *dvert;
972         int a, b;
973         
974         for(a=0, dvert=me->dvert; a<me->totvert; a++, dvert++)
975                 for(b=0; b<dvert->totweight; b++)
976                         if(dw == &dvert->dw[b])
977                                 return BLI_sprintfN("verts[%d].groups[%d]", a, b);
978
979         return NULL;
980 }
981
982 static char *rna_MeshPolygon_path(PointerRNA *ptr)
983 {
984         return BLI_sprintfN("polygons[%d]", (int)((MPoly*)ptr->data - ((Mesh*)ptr->id.data)->mpoly));
985 }
986
987 static char *rna_MeshFace_path(PointerRNA *ptr)
988 {
989         return BLI_sprintfN("faces[%d]", (int)((MFace*)ptr->data - ((Mesh*)ptr->id.data)->mface));
990 }
991
992 static char *rna_MeshEdge_path(PointerRNA *ptr)
993 {
994         return BLI_sprintfN("edges[%d]", (int)((MEdge*)ptr->data - ((Mesh*)ptr->id.data)->medge));
995 }
996
997 static char *rna_MeshLoop_path(PointerRNA *ptr)
998 {
999         return BLI_sprintfN("loops[%d]", (int)((MLoop*)ptr->data - ((Mesh*)ptr->id.data)->mloop));
1000 }
1001
1002
1003 static char *rna_MeshVertex_path(PointerRNA *ptr)
1004 {
1005         return BLI_sprintfN("vertices[%d]", (int)((MVert*)ptr->data - ((Mesh*)ptr->id.data)->mvert));
1006 }
1007
1008 static char *rna_MeshTextureFaceLayer_path(PointerRNA *ptr)
1009 {
1010         return BLI_sprintfN("uv_textures[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
1011 }
1012
1013 static char *rna_CustomDataData_path(PointerRNA *ptr, char *collection, int type)
1014 {
1015         Mesh *me= (Mesh*)ptr->id.data;
1016         CustomData *fdata= rna_mesh_pdata(me);
1017         CustomDataLayer *cdl;
1018         int a, b;
1019
1020         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
1021                 if(cdl->type == type) {
1022                         b= ((char*)ptr->data - ((char*)cdl->data))/CustomData_sizeof(type);
1023                         if(b >= 0 && b < me->totface)
1024                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
1025                 }
1026         }
1027
1028         return NULL;
1029 }
1030
1031 static char *rna_MeshTextureFace_path(PointerRNA *ptr)
1032 {
1033         return rna_CustomDataData_path(ptr, "uv_textures", CD_MTEXPOLY);
1034 }
1035
1036 static char *rna_MeshColorLayer_path(PointerRNA *ptr)
1037 {
1038         return BLI_sprintfN("vertex_colors[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
1039 }
1040
1041 static char *rna_MeshColor_path(PointerRNA *ptr)
1042 {
1043         return rna_CustomDataData_path(ptr, "vertex_colors", CD_MLOOPCOL);
1044 }
1045
1046 static char *rna_MeshSticky_path(PointerRNA *ptr)
1047 {
1048         return BLI_sprintfN("sticky[%d]", (int)((MSticky*)ptr->data - ((Mesh*)ptr->id.data)->msticky));
1049 }
1050
1051 static char *rna_MeshIntPropertyLayer_path(PointerRNA *ptr)
1052 {
1053         return BLI_sprintfN("int_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
1054 }
1055
1056 static char *rna_MeshIntProperty_path(PointerRNA *ptr)
1057 {
1058         return rna_CustomDataData_path(ptr, "layers_int", CD_MCOL);
1059 }
1060
1061 static char *rna_MeshFloatPropertyLayer_path(PointerRNA *ptr)
1062 {
1063         return BLI_sprintfN("float_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
1064 }
1065
1066 static char *rna_MeshFloatProperty_path(PointerRNA *ptr)
1067 {
1068         return rna_CustomDataData_path(ptr, "layers_float", CD_MCOL);
1069 }
1070
1071 static char *rna_MeshStringPropertyLayer_path(PointerRNA *ptr)
1072 {
1073         return BLI_sprintfN("string_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
1074 }
1075
1076 static char *rna_MeshStringProperty_path(PointerRNA *ptr)
1077 {
1078         return rna_CustomDataData_path(ptr, "layers_string", CD_MCOL);
1079 }
1080
1081 static int rna_Mesh_tot_vert_get(PointerRNA *ptr)
1082 {
1083         Mesh *me= (Mesh*)ptr->id.data;
1084         return me->edit_btmesh ? me->edit_btmesh->bm->totvertsel : 0;
1085 }
1086 static int rna_Mesh_tot_edge_get(PointerRNA *ptr)
1087 {
1088         Mesh *me= (Mesh*)ptr->id.data;
1089         return me->edit_btmesh ? me->edit_btmesh->bm->totedgesel: 0;
1090 }
1091 static int rna_Mesh_tot_face_get(PointerRNA *ptr)
1092 {
1093         Mesh *me= (Mesh*)ptr->id.data;
1094         return me->edit_btmesh ? me->edit_btmesh->bm->totfacesel : 0;
1095 }
1096
1097 static CustomDataLayer *rna_Mesh_vertex_color_new(struct Mesh *me, struct bContext *C, const char *name)
1098 {
1099         CustomData *ldata;
1100         CustomDataLayer *cdl= NULL;
1101         int index;
1102
1103         if(ED_mesh_color_add(C, NULL, NULL, me, name, FALSE)) {
1104                 ldata= rna_mesh_ldata(me);
1105                 index= CustomData_get_named_layer_index(ldata, CD_MLOOPCOL, name);
1106                 cdl= (index == -1)? NULL: &ldata->layers[index];
1107         }
1108         return cdl;
1109 }
1110
1111 static CustomDataLayer *rna_Mesh_uv_texture_new(struct Mesh *me, struct bContext *C, const char *name)
1112 {
1113         CustomData *pdata;
1114         CustomDataLayer *cdl= NULL;
1115         int index;
1116
1117         if(ED_mesh_uv_texture_add(C, me, name, FALSE)) {
1118                 pdata= rna_mesh_pdata(me);
1119                 index= CustomData_get_named_layer_index(pdata, CD_MTEXPOLY, name);
1120                 cdl= (index == -1)? NULL: &pdata->layers[index];
1121         }
1122         return cdl;
1123 }
1124
1125 #else
1126
1127 static void rna_def_mvert_group(BlenderRNA *brna)
1128 {
1129         StructRNA *srna;
1130         PropertyRNA *prop;
1131
1132         srna= RNA_def_struct(brna, "VertexGroupElement", NULL);
1133         RNA_def_struct_sdna(srna, "MDeformWeight");
1134         RNA_def_struct_path_func(srna, "rna_VertexGroupElement_path");
1135         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
1136         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
1137
1138         /* we can't point to actual group, it is in the object and so
1139          * there is no unique group to point to, hence the index */
1140         prop= RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
1141         RNA_def_property_int_sdna(prop, NULL, "def_nr");
1142         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1143         RNA_def_property_ui_text(prop, "Group Index", "");
1144         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1145
1146         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
1147         RNA_def_property_range(prop, 0.0f, 1.0f);
1148         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
1149         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1150 }
1151
1152 static void rna_def_mvert(BlenderRNA *brna)
1153 {
1154         StructRNA *srna;
1155         PropertyRNA *prop;
1156
1157         srna= RNA_def_struct(brna, "MeshVertex", NULL);
1158         RNA_def_struct_sdna(srna, "MVert");
1159         RNA_def_struct_ui_text(srna, "Mesh Vertex", "Vertex in a Mesh datablock");
1160         RNA_def_struct_path_func(srna, "rna_MeshVertex_path");
1161         RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
1162
1163         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1164         RNA_def_property_ui_text(prop, "Location", "");
1165         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1166
1167         prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1168         // RNA_def_property_float_sdna(prop, NULL, "no");
1169         RNA_def_property_array(prop, 3);
1170         RNA_def_property_range(prop, -1.0f, 1.0f);
1171         RNA_def_property_float_funcs(prop, "rna_MeshVertex_normal_get", "rna_MeshVertex_normal_set", NULL);
1172         RNA_def_property_ui_text(prop, "Normal", "Vertex Normal");
1173
1174         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1175         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1176         RNA_def_property_ui_text(prop, "Select", "");
1177         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1178
1179         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1180         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1181         RNA_def_property_ui_text(prop, "Hide", "");
1182         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1183
1184         prop= RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1185         RNA_def_property_float_funcs(prop, "rna_MeshVertex_bevel_weight_get", "rna_MeshVertex_bevel_weight_set", NULL);
1186         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier 'Only Vertices' option");
1187         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1188
1189         prop= RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
1190         RNA_def_property_collection_funcs(prop, "rna_MeshVertex_groups_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
1191         RNA_def_property_struct_type(prop, "VertexGroupElement");
1192         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");
1193
1194         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1195         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1196         RNA_def_property_int_funcs(prop, "rna_MeshVertex_index_get", NULL, NULL);
1197         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1198 }
1199
1200 static void rna_def_medge(BlenderRNA *brna)
1201 {
1202         StructRNA *srna;
1203         PropertyRNA *prop;
1204
1205         srna= RNA_def_struct(brna, "MeshEdge", NULL);
1206         RNA_def_struct_sdna(srna, "MEdge");
1207         RNA_def_struct_ui_text(srna, "Mesh Edge", "Edge in a Mesh datablock");
1208         RNA_def_struct_path_func(srna, "rna_MeshEdge_path");
1209         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1210
1211         prop= RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1212         RNA_def_property_int_sdna(prop, NULL, "v1");
1213         RNA_def_property_array(prop, 2);
1214         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1215         // XXX allows creating invalid meshes
1216
1217         prop= RNA_def_property(srna, "crease", PROP_FLOAT, PROP_NONE);
1218         RNA_def_property_float_funcs(prop, "rna_MEdge_crease_get", "rna_MEdge_crease_set", NULL);
1219         RNA_def_property_ui_text(prop, "Crease", "Weight used by the Subsurf modifier for creasing");
1220         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1221
1222         prop= RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
1223         RNA_def_property_float_funcs(prop, "rna_MEdge_bevel_weight_get", "rna_MEdge_bevel_weight_set", NULL);
1224         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier");
1225         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1226
1227         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1228         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1229         RNA_def_property_ui_text(prop, "Select", "");
1230         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1231
1232         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1233         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1234         RNA_def_property_ui_text(prop, "Hide", "");
1235         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1236
1237         prop= RNA_def_property(srna, "use_seam", PROP_BOOLEAN, PROP_NONE);
1238         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SEAM);
1239         RNA_def_property_ui_text(prop, "Seam", "Seam edge for UV unwrapping");
1240         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1241
1242         prop= RNA_def_property(srna, "use_edge_sharp", PROP_BOOLEAN, PROP_NONE);
1243         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SHARP);
1244         RNA_def_property_ui_text(prop, "Sharp", "Sharp edge for the EdgeSplit modifier");
1245         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1246
1247         prop= RNA_def_property(srna, "is_loose", PROP_BOOLEAN, PROP_NONE);
1248         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_LOOSEEDGE);
1249         RNA_def_property_ui_text(prop, "Loose", "Loose edge");
1250
1251         prop= RNA_def_property(srna, "is_fgon", PROP_BOOLEAN, PROP_NONE);
1252         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FGON);
1253         RNA_def_property_ui_text(prop, "Fgon", "Fgon edge");
1254
1255         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1256         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1257         RNA_def_property_int_funcs(prop, "rna_MeshEdge_index_get", NULL, NULL);
1258         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1259 }
1260
1261 static void rna_def_mface(BlenderRNA *brna)
1262 {
1263         StructRNA *srna;
1264         PropertyRNA *prop;
1265
1266         srna= RNA_def_struct(brna, "MeshFace", NULL);
1267         RNA_def_struct_sdna(srna, "MFace");
1268         RNA_def_struct_ui_text(srna, "Mesh Face", "Face in a Mesh datablock");
1269         RNA_def_struct_path_func(srna, "rna_MeshFace_path");
1270         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1271
1272         // XXX allows creating invalid meshes
1273         prop= RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1274         RNA_def_property_array(prop, 4);
1275         RNA_def_property_flag(prop, PROP_DYNAMIC);
1276         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshFace_verts_get_length");
1277         RNA_def_property_int_funcs(prop, "rna_MeshFace_verts_get", "rna_MeshFace_verts_set", NULL);
1278         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1279
1280         /* leaving this fixed size array for foreach_set used in import scripts */
1281         prop= RNA_def_property(srna, "vertices_raw", PROP_INT, PROP_UNSIGNED);
1282         RNA_def_property_int_sdna(prop, NULL, "v1");
1283         RNA_def_property_array(prop, 4);
1284         RNA_def_property_ui_text(prop, "Vertices", "Fixed size vertex indices array");
1285
1286         prop= RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1287         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1288         RNA_def_property_ui_text(prop, "Material Index", "");
1289         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshFace_material_index_range");
1290         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1291
1292         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1293         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1294         RNA_def_property_ui_text(prop, "Select", "");
1295         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1296
1297         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1298         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1299         RNA_def_property_ui_text(prop, "Hide", "");
1300         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1301
1302         prop= RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1303         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1304         RNA_def_property_ui_text(prop, "Smooth", "");
1305         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1306         
1307         prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1308         RNA_def_property_array(prop, 3);
1309         RNA_def_property_range(prop, -1.0f, 1.0f);
1310         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1311         RNA_def_property_float_funcs(prop, "rna_MeshFace_normal_get", NULL, NULL);
1312         RNA_def_property_ui_text(prop, "face normal", "local space unit length normal vector for this face");
1313
1314         prop= RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1315         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1316         RNA_def_property_float_funcs(prop, "rna_MeshFace_area_get", NULL, NULL);
1317         RNA_def_property_ui_text(prop, "face area", "read only area of the face");
1318
1319         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1320         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1321         RNA_def_property_int_funcs(prop, "rna_MeshFace_index_get", NULL, NULL);
1322         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1323 }
1324
1325
1326 static void rna_def_mloop(BlenderRNA *brna)
1327 {
1328         StructRNA *srna;
1329         PropertyRNA *prop;
1330
1331         srna= RNA_def_struct(brna, "MeshLoop", NULL);
1332         RNA_def_struct_sdna(srna, "MLoop");
1333         RNA_def_struct_ui_text(srna, "Mesh Loop", "Loop in a Mesh datablock");
1334         RNA_def_struct_path_func(srna, "rna_MeshLoop_path");
1335         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
1336
1337         prop= RNA_def_property(srna, "vertex_index", PROP_INT, PROP_UNSIGNED);
1338         RNA_def_property_int_sdna(prop, NULL, "v");
1339         RNA_def_property_ui_text(prop, "Vertex", "Vertex index");
1340
1341         prop= RNA_def_property(srna, "edge_index", PROP_INT, PROP_UNSIGNED);
1342         RNA_def_property_int_sdna(prop, NULL, "e");
1343         RNA_def_property_ui_text(prop, "Edge", "Edge index");
1344 }
1345
1346 static void rna_def_mpolygon(BlenderRNA *brna)
1347 {
1348         StructRNA *srna;
1349         PropertyRNA *prop;
1350
1351         srna= RNA_def_struct(brna, "MeshPolygon", NULL);
1352         RNA_def_struct_sdna(srna, "MPoly");
1353         RNA_def_struct_ui_text(srna, "Mesh Polygon", "Polygon in a Mesh datablock");
1354         RNA_def_struct_path_func(srna, "rna_MeshPolygon_path");
1355         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
1356
1357         /* faked, actually access to loop vertex values, dont this way because manually setting up vertex/edge per loop is very low level
1358          * instead we setup poly sizes, assign indicies, then calc edges automatic when creating meshes from rna/py */
1359         prop= RNA_def_property(srna, "vertices", PROP_INT, PROP_UNSIGNED);
1360         RNA_def_property_array(prop, 3); // eek, this is still used in some cases but infact we dont want to use it at all here.
1361         RNA_def_property_flag(prop, PROP_DYNAMIC);
1362         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshPoly_vertices_get_length");
1363         RNA_def_property_int_funcs(prop, "rna_MeshPoly_vertices_get", "rna_MeshPoly_vertices_set", NULL);
1364         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
1365
1366         /* these are both very low level access */
1367         prop= RNA_def_property(srna, "loop_start", PROP_INT, PROP_UNSIGNED);
1368         RNA_def_property_int_sdna(prop, NULL, "loopstart");
1369         RNA_def_property_ui_text(prop, "Loop Start", "");
1370         /* also low level */
1371         prop= RNA_def_property(srna, "loop_total", PROP_INT, PROP_UNSIGNED);
1372         RNA_def_property_int_sdna(prop, NULL, "totloop");
1373         RNA_def_property_ui_text(prop, "Loop Total", "");
1374
1375         prop= RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1376         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1377         RNA_def_property_ui_text(prop, "Material Index", "");
1378         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshFace_material_index_range");
1379         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1380
1381         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1382         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1383         RNA_def_property_ui_text(prop, "Select", "");
1384         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1385
1386         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1387         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1388         RNA_def_property_ui_text(prop, "Hide", "");
1389         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1390
1391         prop= RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1392         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1393         RNA_def_property_ui_text(prop, "Smooth", "");
1394         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1395
1396         prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1397         RNA_def_property_array(prop, 3);
1398         RNA_def_property_range(prop, -1.0f, 1.0f);
1399         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1400         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_normal_get", NULL, NULL);
1401         RNA_def_property_ui_text(prop, "face normal", "local space unit length normal vector for this polygon");
1402
1403 #if 0 /* BMESH_TODO */
1404         prop= RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1405         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1406         RNA_def_property_float_funcs(prop, "rna_MeshPolygon_area_get", NULL, NULL);
1407         RNA_def_property_ui_text(prop, "face area", "read only area of the face");
1408 #endif
1409
1410         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1411         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1412         RNA_def_property_int_funcs(prop, "rna_MeshPolygon_index_get", NULL, NULL);
1413         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex");
1414 }
1415
1416 static void rna_def_mtexpoly(BlenderRNA *brna)
1417 {
1418         StructRNA *srna;
1419         PropertyRNA *prop;
1420 #if 0  /* BMESH_TODO: needed later when do another todo */
1421         int uv_dim[]= {4, 2};
1422 #endif
1423
1424         srna= RNA_def_struct(brna, "MeshTextureFaceLayer", NULL);
1425         RNA_def_struct_ui_text(srna, "Mesh Texture Face Layer", "Layer of texture faces in a Mesh datablock");
1426         RNA_def_struct_sdna(srna, "CustomDataLayer");
1427         RNA_def_struct_path_func(srna, "rna_MeshTextureFaceLayer_path");
1428         RNA_def_struct_ui_icon(srna, ICON_GROUP_UVS);
1429
1430         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1431         RNA_def_struct_name_property(srna, prop);
1432         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshTextureFaceLayer_name_set");
1433         RNA_def_property_ui_text(prop, "Name", "Name of UV unwrapping layer");
1434         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1435
1436         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1437         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_get", "rna_MeshTextureFaceLayer_active_set");
1438         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1439         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1440
1441         prop= RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1442         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1443         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_render_get", "rna_MeshTextureFaceLayer_active_render_set");
1444         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1445         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1446
1447         prop= RNA_def_property(srna, "active_clone", PROP_BOOLEAN, PROP_NONE);
1448         RNA_def_property_boolean_sdna(prop, NULL, "active_clone", 0);
1449         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_clone_get", "rna_MeshTextureFaceLayer_clone_set");
1450         RNA_def_property_ui_text(prop, "Active Clone", "Sets the layer as active for cloning");
1451         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1452
1453         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1454         RNA_def_property_struct_type(prop, "MeshTextureFace");
1455         RNA_def_property_ui_text(prop, "Data", "");
1456         RNA_def_property_collection_funcs(prop, "rna_MeshTextureFaceLayer_data_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_MeshTextureFaceLayer_data_length", NULL, NULL, NULL);
1457
1458         srna= RNA_def_struct(brna, "MeshTextureFace", NULL);
1459         RNA_def_struct_sdna(srna, "MTexPoly");
1460         RNA_def_struct_ui_text(srna, "Mesh Texture Face", "UV mapping, texturing and game engine data for a face");
1461         RNA_def_struct_path_func(srna, "rna_MeshTextureFace_path");
1462         RNA_def_struct_ui_icon(srna, ICON_FACESEL_HLT);
1463
1464         prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1465         RNA_def_property_pointer_sdna(prop, NULL, "tpage");
1466         RNA_def_property_pointer_funcs(prop, NULL, "rna_TextureFace_image_set", NULL, NULL);
1467         RNA_def_property_flag(prop, PROP_EDITABLE);
1468         RNA_def_property_ui_text(prop, "Image", "");
1469         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1470
1471         prop= RNA_def_property(srna, "select_uv", PROP_BOOLEAN, PROP_NONE);
1472         RNA_def_property_boolean_sdna(prop, NULL, "flag", TF_SEL1);
1473         RNA_def_property_array(prop, 4);
1474         RNA_def_property_ui_text(prop, "UV Selected", "");
1475         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1476
1477 #if 0 /*BMESH_TODO*/
1478         prop= RNA_def_property(srna, "pin_uv", PROP_BOOLEAN, PROP_NONE);
1479         RNA_def_property_boolean_sdna(prop, NULL, "unwrap", TF_PIN1);
1480         RNA_def_property_array(prop, 4);
1481         RNA_def_property_ui_text(prop, "UV Pinned", "");
1482         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1483
1484         prop= RNA_def_property(srna, "uv", PROP_FLOAT, PROP_NONE);
1485         RNA_def_property_multi_array(prop, 2, uv_dim);
1486         RNA_def_property_flag(prop, PROP_DYNAMIC);
1487         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshTextureFace_uv_get_length");
1488         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv_get", "rna_MeshTextureFace_uv_set", NULL);
1489         RNA_def_property_ui_text(prop, "UV", "");
1490         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1491
1492         prop= RNA_def_property(srna, "uv_raw", PROP_FLOAT, PROP_NONE);
1493         RNA_def_property_multi_array(prop, 2, uv_dim);
1494         RNA_def_property_float_sdna(prop, NULL, "uv");
1495         RNA_def_property_ui_text(prop, "UV", "Fixed size UV coordinates array");
1496 #endif
1497 }
1498
1499 static void rna_def_msticky(BlenderRNA *brna)
1500 {
1501         StructRNA *srna;
1502         PropertyRNA *prop;
1503
1504         srna= RNA_def_struct(brna, "MeshSticky", NULL);
1505         RNA_def_struct_sdna(srna, "MSticky");
1506         RNA_def_struct_ui_text(srna, "Mesh Vertex Sticky Texture Coordinate", "Stricky texture coordinate");
1507         RNA_def_struct_path_func(srna, "rna_MeshSticky_path");
1508
1509         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
1510         RNA_def_property_ui_text(prop, "Location", "Sticky texture coordinate location");
1511         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1512 }
1513
1514 static void rna_def_mloopcol(BlenderRNA *brna)
1515 {
1516         StructRNA *srna;
1517         PropertyRNA *prop;
1518
1519         srna= RNA_def_struct(brna, "MeshColorLayer", NULL);
1520         RNA_def_struct_ui_text(srna, "Mesh Vertex Color Layer", "Layer of vertex colors in a Mesh datablock");
1521         RNA_def_struct_sdna(srna, "CustomDataLayer");
1522         RNA_def_struct_path_func(srna, "rna_MeshColorLayer_path");
1523         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
1524
1525         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1526         RNA_def_struct_name_property(srna, prop);
1527         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshColorLayer_name_set");
1528         RNA_def_property_ui_text(prop, "Name", "Name of Vertex color layer");
1529         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1530
1531         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1532         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_get", "rna_MeshColorLayer_active_set");
1533         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1534         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1535
1536         prop= RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1537         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1538         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_render_get", "rna_MeshColorLayer_active_render_set");
1539         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1540         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1541
1542         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1543         RNA_def_property_struct_type(prop, "MeshColor");
1544         RNA_def_property_ui_text(prop, "Data", "");
1545         RNA_def_property_collection_funcs(prop, "rna_MeshColorLayer_data_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_MeshColorLayer_data_length", NULL, NULL, NULL);
1546
1547         srna= RNA_def_struct(brna, "MeshColor", NULL);
1548         RNA_def_struct_sdna(srna, "MCol");
1549         RNA_def_struct_ui_text(srna, "Mesh Vertex Color", "Vertex colors for a face in a Mesh");
1550         RNA_def_struct_path_func(srna, "rna_MeshColor_path");
1551
1552         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1553 }
1554
1555 static void rna_def_mproperties(BlenderRNA *brna)
1556 {
1557         StructRNA *srna;
1558         PropertyRNA *prop;
1559
1560         /* Float */
1561         srna= RNA_def_struct(brna, "MeshFloatPropertyLayer", NULL);
1562         RNA_def_struct_sdna(srna, "CustomDataLayer");
1563         RNA_def_struct_ui_text(srna, "Mesh Float Property Layer", "User defined layer of floating pointer number values");
1564         RNA_def_struct_path_func(srna, "rna_MeshFloatPropertyLayer_path");
1565
1566         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1567         RNA_def_struct_name_property(srna, prop);
1568         RNA_def_property_ui_text(prop, "Name", "");
1569         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1570
1571         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1572         RNA_def_property_struct_type(prop, "MeshFloatProperty");
1573         RNA_def_property_ui_text(prop, "Data", "");
1574         RNA_def_property_collection_funcs(prop, "rna_MeshFloatPropertyLayer_data_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_MeshFloatPropertyLayer_data_length", NULL, NULL, NULL);
1575
1576         srna= RNA_def_struct(brna, "MeshFloatProperty", NULL);
1577         RNA_def_struct_sdna(srna, "MFloatProperty");
1578         RNA_def_struct_ui_text(srna, "Mesh Float Property", "User defined floating point number value in a float properties layer");
1579         RNA_def_struct_path_func(srna, "rna_MeshFloatProperty_path");
1580
1581         prop= RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
1582         RNA_def_property_float_sdna(prop, NULL, "f");
1583         RNA_def_property_ui_text(prop, "Value", "");
1584         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1585
1586         /* Int */
1587         srna= RNA_def_struct(brna, "MeshIntPropertyLayer", NULL);
1588         RNA_def_struct_sdna(srna, "CustomDataLayer");
1589         RNA_def_struct_ui_text(srna, "Mesh Int Property Layer", "User defined layer of integer number values");
1590         RNA_def_struct_path_func(srna, "rna_MeshIntPropertyLayer_path");
1591
1592         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1593         RNA_def_struct_name_property(srna, prop);
1594         RNA_def_property_ui_text(prop, "Name", "");
1595         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1596
1597         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1598         RNA_def_property_struct_type(prop, "MeshIntProperty");
1599         RNA_def_property_ui_text(prop, "Data", "");
1600         RNA_def_property_collection_funcs(prop, "rna_MeshIntPropertyLayer_data_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_MeshIntPropertyLayer_data_length", NULL, NULL, NULL);
1601
1602         srna= RNA_def_struct(brna, "MeshIntProperty", NULL);
1603         RNA_def_struct_sdna(srna, "MIntProperty");
1604         RNA_def_struct_ui_text(srna, "Mesh Int Property", "User defined integer number value in an integer properties layer");
1605         RNA_def_struct_path_func(srna, "rna_MeshIntProperty_path");
1606
1607         prop= RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
1608         RNA_def_property_int_sdna(prop, NULL, "i");
1609         RNA_def_property_ui_text(prop, "Value", "");
1610         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1611
1612         /* String */
1613         srna= RNA_def_struct(brna, "MeshStringPropertyLayer", NULL);
1614         RNA_def_struct_sdna(srna, "CustomDataLayer");
1615         RNA_def_struct_ui_text(srna, "Mesh String Property Layer", "User defined layer of string text values");
1616         RNA_def_struct_path_func(srna, "rna_MeshStringPropertyLayer_path");
1617
1618         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1619         RNA_def_struct_name_property(srna, prop);
1620         RNA_def_property_ui_text(prop, "Name", "");
1621         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1622
1623         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1624         RNA_def_property_struct_type(prop, "MeshStringProperty");
1625         RNA_def_property_ui_text(prop, "Data", "");
1626         RNA_def_property_collection_funcs(prop, "rna_MeshStringPropertyLayer_data_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_MeshStringPropertyLayer_data_length", NULL, NULL, NULL);
1627
1628         srna= RNA_def_struct(brna, "MeshStringProperty", NULL);
1629         RNA_def_struct_sdna(srna, "MStringProperty");
1630         RNA_def_struct_ui_text(srna, "Mesh String Property", "User defined string text value in a string properties layer");
1631         RNA_def_struct_path_func(srna, "rna_MeshStringProperty_path");
1632
1633         prop= RNA_def_property(srna, "value", PROP_STRING, PROP_NONE);
1634         RNA_def_property_string_sdna(prop, NULL, "s");
1635         RNA_def_property_ui_text(prop, "Value", "");
1636         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1637 }
1638
1639 void rna_def_texmat_common(StructRNA *srna, const char *texspace_editable)
1640 {
1641         PropertyRNA *prop;
1642
1643         /* texture space */
1644         prop= RNA_def_property(srna, "auto_texspace", PROP_BOOLEAN, PROP_NONE);
1645         RNA_def_property_boolean_sdna(prop, NULL, "texflag", AUTOSPACE);
1646         RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjusts active object's texture space automatically when transforming object");
1647
1648         prop= RNA_def_property(srna, "texspace_loc", PROP_FLOAT, PROP_TRANSLATION);
1649         RNA_def_property_float_sdna(prop, NULL, "loc");
1650         RNA_def_property_ui_text(prop, "Texure Space Location", "Texture space location");
1651         RNA_def_property_editable_func(prop, texspace_editable);
1652         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1653
1654         prop= RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
1655         RNA_def_property_float_sdna(prop, NULL, "size");
1656         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size");
1657         RNA_def_property_editable_func(prop, texspace_editable);
1658         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1659
1660         /* not supported yet
1661         prop= RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
1662         RNA_def_property_float(prop, NULL, "rot");
1663         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
1664         RNA_def_property_editable_func(prop, texspace_editable);
1665         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");*/
1666
1667         /* materials */
1668         prop= RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1669         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1670         RNA_def_property_struct_type(prop, "Material");
1671         RNA_def_property_ui_text(prop, "Materials", "");
1672         RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
1673         RNA_def_property_collection_funcs(prop, 0, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
1674 }
1675
1676
1677 /* scene.objects */
1678 /* mesh.vertices */
1679 static void rna_def_mesh_vertices(BlenderRNA *brna, PropertyRNA *cprop)
1680 {
1681         StructRNA *srna;
1682 //      PropertyRNA *prop;
1683
1684         FunctionRNA *func;
1685 //      PropertyRNA *parm;
1686
1687         RNA_def_property_srna(cprop, "MeshVertices");
1688         srna= RNA_def_struct(brna, "MeshVertices", NULL);
1689         RNA_def_struct_sdna(srna, "Mesh");
1690         RNA_def_struct_ui_text(srna, "Mesh Vertices", "Collection of mesh vertices");
1691
1692         func= RNA_def_function(srna, "add", "ED_mesh_vertices_add");
1693         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1694         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to add", 0, INT_MAX);
1695 }
1696
1697 /* mesh.edges */
1698 static void rna_def_mesh_edges(BlenderRNA *brna, PropertyRNA *cprop)
1699 {
1700         StructRNA *srna;
1701 //      PropertyRNA *prop;
1702
1703         FunctionRNA *func;
1704 //      PropertyRNA *parm;
1705
1706         RNA_def_property_srna(cprop, "MeshEdges");
1707         srna= RNA_def_struct(brna, "MeshEdges", NULL);
1708         RNA_def_struct_sdna(srna, "Mesh");
1709         RNA_def_struct_ui_text(srna, "Mesh Edges", "Collection of mesh edges");
1710
1711         func= RNA_def_function(srna, "add", "ED_mesh_edges_add");
1712         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1713         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to add", 0, INT_MAX);
1714 }
1715
1716 /* mesh.faces */
1717 static void rna_def_mesh_faces(BlenderRNA *brna, PropertyRNA *cprop)
1718 {
1719         StructRNA *srna;
1720         PropertyRNA *prop;
1721
1722         FunctionRNA *func;
1723         PropertyRNA *parm;
1724
1725         RNA_def_property_srna(cprop, "MeshFaces");
1726         srna= RNA_def_struct(brna, "MeshFaces", NULL);
1727         RNA_def_struct_sdna(srna, "Mesh");
1728         RNA_def_struct_ui_text(srna, "Mesh Faces", "Collection of mesh faces");
1729
1730         prop= RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
1731         RNA_def_property_int_sdna(prop, NULL, "act_face");
1732         RNA_def_property_ui_text(prop, "Active Face", "The active face for this mesh");
1733
1734         func= RNA_def_function(srna, "add", "ED_mesh_faces_add");
1735         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1736         parm= RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of vertices to add", 0, INT_MAX);
1737 }
1738
1739 /* mesh.loops */
1740 static void rna_def_mesh_loops(BlenderRNA *brna, PropertyRNA *cprop)
1741 {
1742         StructRNA *srna;
1743
1744         /*PropertyRNA *prop;*/
1745
1746         FunctionRNA *func;
1747         /*PropertyRNA *parm;*/
1748
1749         RNA_def_property_srna(cprop, "MeshLoops");
1750         srna= RNA_def_struct(brna, "MeshLoops", NULL);
1751         RNA_def_struct_sdna(srna, "Mesh");
1752         RNA_def_struct_ui_text(srna, "Mesh Loops", "Collection of mesh loops");
1753
1754 #if 0 // BMESH_TODO
1755         prop= RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
1756         RNA_def_property_int_sdna(prop, NULL, "act_face");
1757         RNA_def_property_ui_text(prop, "Active Polygon", "The active polygon for this mesh");
1758 #endif
1759
1760         func= RNA_def_function(srna, "add", "ED_mesh_loops_add");
1761         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1762         RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of loops to add", 0, INT_MAX);
1763 }
1764
1765 /* mesh.polygons */
1766 static void rna_def_mesh_polygons(BlenderRNA *brna, PropertyRNA *cprop)
1767 {
1768         StructRNA *srna;
1769
1770 //      PropertyRNA *prop;
1771
1772         FunctionRNA *func;
1773         PropertyRNA *parm;
1774
1775         RNA_def_property_srna(cprop, "MeshPolygons");
1776         srna= RNA_def_struct(brna, "MeshPolygons", NULL);
1777         RNA_def_struct_sdna(srna, "Mesh");
1778         RNA_def_struct_ui_text(srna, "Mesh Polygons", "Collection of mesh polygons");
1779
1780 #if 0 // BMESH_TODO
1781         prop= RNA_def_property(srna, "active", PROP_INT, PROP_NONE);
1782         RNA_def_property_int_sdna(prop, NULL, "act_face");
1783         RNA_def_property_ui_text(prop, "Active Polygon", "The active polygon for this mesh");
1784 #endif
1785
1786         func= RNA_def_function(srna, "add", "ED_mesh_polys_add");
1787         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1788         parm= RNA_def_int(func, "count", 0, 0, INT_MAX, "Count", "Number of polygons to add", 0, INT_MAX);
1789 }
1790
1791
1792 /* mesh.vertex_colors */
1793 static void rna_def_vertex_colors(BlenderRNA *brna, PropertyRNA *cprop)
1794 {
1795         StructRNA *srna;
1796         PropertyRNA *prop;
1797
1798         FunctionRNA *func;
1799         PropertyRNA *parm;
1800
1801         RNA_def_property_srna(cprop, "VertexColors");
1802         srna= RNA_def_struct(brna, "VertexColors", NULL);
1803         RNA_def_struct_sdna(srna, "Mesh");
1804         RNA_def_struct_ui_text(srna, "Vertex Colors", "Collection of vertex colors");
1805         
1806         func= RNA_def_function(srna, "new", "rna_Mesh_vertex_color_new");
1807         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1808         RNA_def_function_ui_description(func, "Add a vertex color layer to Mesh");
1809         RNA_def_string(func, "name", "Col", 0, "", "Vertex color name");
1810         parm= RNA_def_pointer(func, "layer", "MeshColorLayer", "", "The newly created layer");
1811         RNA_def_function_return(func, parm);
1812         
1813 /*
1814         func= RNA_def_function(srna, "remove", "rna_Mesh_vertex_color_remove");
1815         RNA_def_function_ui_description(func, "Remove a vertex color layer");
1816         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1817         parm= RNA_def_pointer(func, "layer", "Layer", "", "The layer to remove");
1818         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1819 */
1820         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_UNSIGNED);
1821         RNA_def_property_struct_type(prop, "MeshColorLayer");
1822         RNA_def_property_pointer_funcs(prop, "rna_Mesh_active_vertex_color_get", "rna_Mesh_active_vertex_color_set", NULL, NULL);
1823         RNA_def_property_flag(prop, PROP_EDITABLE);
1824         RNA_def_property_ui_text(prop, "Active Vertex Color Layer", "Active vertex color layer");
1825         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1826         
1827         prop= RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1828         RNA_def_property_int_funcs(prop, "rna_Mesh_active_vertex_color_index_get", "rna_Mesh_active_vertex_color_index_set", "rna_Mesh_active_vertex_color_index_range");
1829         RNA_def_property_ui_text(prop, "Active Vertex Color Index", "Active vertex color index");
1830         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1831 }
1832
1833 /* mesh.uv_layers */
1834 static void rna_def_uv_textures(BlenderRNA *brna, PropertyRNA *cprop)
1835 {
1836         StructRNA *srna;
1837         PropertyRNA *prop;
1838
1839         FunctionRNA *func;
1840         PropertyRNA *parm;
1841
1842         RNA_def_property_srna(cprop, "UVTextures");
1843         srna= RNA_def_struct(brna, "UVTextures", NULL);
1844         RNA_def_struct_sdna(srna, "Mesh");
1845         RNA_def_struct_ui_text(srna, "UV Textures", "Collection of uv textures");
1846         
1847         func= RNA_def_function(srna, "new", "rna_Mesh_uv_texture_new");
1848         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1849         RNA_def_function_ui_description(func, "Add a UV texture layer to Mesh");
1850         RNA_def_string(func, "name", "UVTex", 0, "", "UV Texture name");
1851         parm= RNA_def_pointer(func, "layer", "MeshTextureFaceLayer", "", "The newly created layer");
1852         RNA_def_function_return(func, parm);
1853
1854 /*
1855         func= RNA_def_function(srna, "remove", "rna_Mesh_uv_layers_remove");
1856         RNA_def_function_ui_description(func, "Remove a vertex color layer");
1857         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1858         parm= RNA_def_pointer(func, "layer", "Layer", "", "The layer to remove");
1859         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1860 */
1861         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_UNSIGNED);
1862         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1863         RNA_def_property_pointer_funcs(prop, "rna_Mesh_active_uv_texture_get", "rna_Mesh_active_uv_texture_set", NULL, NULL);
1864         RNA_def_property_flag(prop, PROP_EDITABLE);
1865         RNA_def_property_ui_text(prop, "Active UV Texture", "Active UV texture");
1866         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1867
1868         prop= RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1869         RNA_def_property_int_funcs(prop, "rna_Mesh_active_uv_texture_index_get", "rna_Mesh_active_uv_texture_index_set", "rna_Mesh_active_uv_texture_index_range");
1870         RNA_def_property_ui_text(prop, "Active UV Texture Index", "Active UV texture index");
1871         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1872 }
1873
1874 static void rna_def_mesh(BlenderRNA *brna)
1875 {
1876         StructRNA *srna;
1877         PropertyRNA *prop;
1878
1879         srna= RNA_def_struct(brna, "Mesh", "ID");
1880         RNA_def_struct_ui_text(srna, "Mesh", "Mesh datablock defining geometric surfaces");
1881         RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
1882
1883         prop= RNA_def_property(srna, "vertices", PROP_COLLECTION, PROP_NONE);
1884         RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
1885         RNA_def_property_struct_type(prop, "MeshVertex");
1886         RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh");
1887         rna_def_mesh_vertices(brna, prop);
1888
1889         prop= RNA_def_property(srna, "edges", PROP_COLLECTION, PROP_NONE);
1890         RNA_def_property_collection_sdna(prop, NULL, "medge", "totedge");
1891         RNA_def_property_struct_type(prop, "MeshEdge");
1892         RNA_def_property_ui_text(prop, "Edges", "Edges of the mesh");
1893         rna_def_mesh_edges(brna, prop);
1894
1895         prop= RNA_def_property(srna, "faces", PROP_COLLECTION, PROP_NONE);
1896         RNA_def_property_collection_sdna(prop, NULL, "mface", "totface");
1897         RNA_def_property_struct_type(prop, "MeshFace");
1898         RNA_def_property_ui_text(prop, "Faces", "Faces of the mesh");
1899         rna_def_mesh_faces(brna, prop);
1900
1901         prop= RNA_def_property(srna, "loops", PROP_COLLECTION, PROP_NONE);
1902         RNA_def_property_collection_sdna(prop, NULL, "mloop", "totloop");
1903         RNA_def_property_struct_type(prop, "MeshLoop");
1904         RNA_def_property_ui_text(prop, "Loops", "Loops of the mesh");
1905         rna_def_mesh_loops(brna, prop);
1906
1907         prop= RNA_def_property(srna, "polygons", PROP_COLLECTION, PROP_NONE);
1908         RNA_def_property_collection_sdna(prop, NULL, "mpoly", "totpoly");
1909         RNA_def_property_struct_type(prop, "MeshPolygon");
1910         RNA_def_property_ui_text(prop, "Polygons", "Polygons of the mesh");
1911         rna_def_mesh_polygons(brna, prop);
1912
1913         prop= RNA_def_property(srna, "sticky", PROP_COLLECTION, PROP_NONE);
1914         RNA_def_property_collection_sdna(prop, NULL, "msticky", "totvert");
1915         RNA_def_property_struct_type(prop, "MeshSticky");
1916         RNA_def_property_ui_text(prop, "Sticky", "Sticky texture coordinates");
1917
1918         /* TODO, should this be allowed to be its self? */
1919         prop= RNA_def_property(srna, "texture_mesh", PROP_POINTER, PROP_NONE);
1920         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
1921         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
1922         RNA_def_property_ui_text(prop, "Texture Mesh", "Use another mesh for texture indicies (vertex indicies must be aligned)");
1923
1924         /* UV textures */
1925         prop= RNA_def_property(srna, "uv_textures", PROP_COLLECTION, PROP_NONE);
1926         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1927         RNA_def_property_collection_funcs(prop, "rna_Mesh_uv_textures_begin", NULL, NULL, NULL, "rna_Mesh_uv_textures_length", NULL, NULL, NULL);
1928         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1929         RNA_def_property_ui_text(prop, "UV Textures", "");
1930         rna_def_uv_textures(brna, prop);
1931
1932         prop= RNA_def_property(srna, "uv_texture_clone", PROP_POINTER, PROP_UNSIGNED);
1933         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1934         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_texture_clone_get", "rna_Mesh_uv_texture_clone_set", NULL, NULL);
1935         RNA_def_property_flag(prop, PROP_EDITABLE);
1936         RNA_def_property_ui_text(prop, "Clone UV Texture", "UV texture to be used as cloning source");
1937
1938         prop= RNA_def_property(srna, "uv_texture_clone_index", PROP_INT, PROP_UNSIGNED);
1939         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_texture_clone_index_get", "rna_Mesh_uv_texture_clone_index_set", "rna_Mesh_active_uv_texture_index_range");
1940         RNA_def_property_ui_text(prop, "Clone UV Texture Index", "Clone UV texture index");
1941
1942         prop= RNA_def_property(srna, "uv_texture_stencil", PROP_POINTER, PROP_UNSIGNED);
1943         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1944         RNA_def_property_pointer_funcs(prop, "rna_Mesh_uv_texture_stencil_get", "rna_Mesh_uv_texture_stencil_set", NULL, NULL);
1945         RNA_def_property_flag(prop, PROP_EDITABLE);
1946         RNA_def_property_ui_text(prop, "Mask UV Texture", "UV texture to mask the painted area");
1947
1948         prop= RNA_def_property(srna, "uv_texture_stencil_index", PROP_INT, PROP_UNSIGNED);
1949         RNA_def_property_int_funcs(prop, "rna_Mesh_uv_texture_stencil_index_get", "rna_Mesh_uv_texture_stencil_index_set", "rna_Mesh_active_uv_texture_index_range");
1950         RNA_def_property_ui_text(prop, "Mask UV Texture Index", "Mask UV texture index");
1951
1952         /* Vertex colors */
1953
1954         prop= RNA_def_property(srna, "vertex_colors", PROP_COLLECTION, PROP_NONE);
1955         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
1956         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_colors_begin", NULL, NULL, NULL, "rna_Mesh_vertex_colors_length", NULL, NULL, NULL);
1957         RNA_def_property_struct_type(prop, "MeshColorLayer");
1958         RNA_def_property_ui_text(prop, "Vertex Colors", "");
1959         rna_def_vertex_colors(brna, prop);
1960
1961         prop= RNA_def_property(srna, "layers_float", PROP_COLLECTION, PROP_NONE);
1962         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1963         RNA_def_property_collection_funcs(prop, "rna_Mesh_float_layers_begin", NULL, NULL, NULL, "rna_Mesh_float_layers_length", NULL, NULL, NULL);
1964         RNA_def_property_struct_type(prop, "MeshFloatPropertyLayer");
1965         RNA_def_property_ui_text(prop, "Float Property Layers", "");
1966
1967         prop= RNA_def_property(srna, "layers_int", PROP_COLLECTION, PROP_NONE);
1968         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1969         RNA_def_property_collection_funcs(prop, "rna_Mesh_int_layers_begin", NULL, NULL, NULL, "rna_Mesh_int_layers_length", NULL, NULL, NULL);
1970         RNA_def_property_struct_type(prop, "MeshIntPropertyLayer");
1971         RNA_def_property_ui_text(prop, "Int Property Layers", "");
1972
1973         prop= RNA_def_property(srna, "layers_string", PROP_COLLECTION, PROP_NONE);
1974         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1975         RNA_def_property_collection_funcs(prop, "rna_Mesh_string_layers_begin", NULL, NULL, NULL, "rna_Mesh_string_layers_length", NULL, NULL, NULL);
1976         RNA_def_property_struct_type(prop, "MeshStringPropertyLayer");
1977         RNA_def_property_ui_text(prop, "String Property Layers", "");
1978
1979         prop= RNA_def_property(srna, "use_auto_smooth", PROP_BOOLEAN, PROP_NONE);
1980         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_AUTOSMOOTH);
1981         RNA_def_property_ui_text(prop, "Auto Smooth", "Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render");
1982
1983 #if 1 /* expose as radians */
1984         prop= RNA_def_property(srna, "auto_smooth_angle", PROP_FLOAT, PROP_ANGLE);
1985         RNA_def_property_float_funcs(prop, "rna_Mesh_auto_smooth_angle_get", "rna_Mesh_auto_smooth_angle_set", NULL);
1986         RNA_def_property_ui_range(prop, DEG2RAD(1.0), DEG2RAD(80), 1.0, 1);
1987 #else
1988         prop= RNA_def_property(srna, "auto_smooth_angle", PROP_INT, PROP_NONE);
1989         RNA_def_property_int_sdna(prop, NULL, "smoothresh");
1990         RNA_def_property_range(prop, 1, 80);
1991 #endif
1992         RNA_def_property_ui_text(prop, "Auto Smooth Angle", "Defines maximum angle between face normals that 'Auto Smooth' will operate on");
1993
1994         prop= RNA_def_property(srna, "show_double_sided", PROP_BOOLEAN, PROP_NONE);
1995         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_TWOSIDED);
1996         RNA_def_property_ui_text(prop, "Double Sided", "Render/display the mesh with double or single sided lighting");
1997         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1998
1999         prop= RNA_def_property(srna, "texco_mesh", PROP_POINTER, PROP_NONE);
2000         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
2001         RNA_def_property_flag(prop, PROP_EDITABLE);
2002         RNA_def_property_ui_text(prop, "Texture Space Mesh", "Derive texture coordinates from another mesh");
2003
2004         prop= RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
2005         RNA_def_property_pointer_sdna(prop, NULL, "key");
2006         RNA_def_property_ui_text(prop, "Shape Keys", "");
2007         
2008         /* texture space */
2009         prop= RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
2010         RNA_def_property_boolean_sdna(prop, NULL, "texflag", AUTOSPACE);
2011         RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjusts active object's texture space automatically when transforming object");
2012         
2013         /*prop= RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
2014         RNA_def_property_array(prop, 3);
2015         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
2016         RNA_def_property_editable_func(prop, "rna_Mesh_texspace_editable");
2017         RNA_def_property_float_funcs(prop, "rna_Mesh_texspace_loc_get", "rna_Mesh_texspace_loc_set", NULL);     
2018         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2019         */
2020         
2021         /* not supported yet
2022          prop= RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
2023          RNA_def_property_float(prop, NULL, "rot");
2024          RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
2025          RNA_def_property_editable_func(prop, texspace_editable);
2026          RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");*/
2027
2028         /* Mesh Draw Options for Edit Mode*/
2029         
2030         prop= RNA_def_property(srna, "show_edges", PROP_BOOLEAN, PROP_NONE);
2031         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEDGES);
2032         RNA_def_property_ui_text(prop, "Draw Edges", "Displays selected edges using hilights in the 3D view and UV editor");
2033         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2034         
2035         prop= RNA_def_property(srna, "show_all_edges", PROP_BOOLEAN, PROP_NONE);
2036         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_ALLEDGES);
2037         RNA_def_property_ui_text(prop, "All Edges", "Displays all edges for wireframe in all view modes in the 3D view");
2038         RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, NULL);
2039
2040         prop= RNA_def_property(srna, "show_faces", PROP_BOOLEAN, PROP_NONE);
2041         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWFACES);
2042         RNA_def_property_ui_text(prop, "Draw Faces", "Displays all faces as shades in the 3D view and UV editor");
2043         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2044         
2045         prop= RNA_def_property(srna, "show_normal_face", PROP_BOOLEAN, PROP_NONE);
2046         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWNORMALS);
2047         RNA_def_property_ui_text(prop, "Draw Normals", "Displays face normals as lines");
2048         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2049         
2050         prop= RNA_def_property(srna, "show_normal_vertex", PROP_BOOLEAN, PROP_NONE);
2051         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_VNORMALS);
2052         RNA_def_property_ui_text(prop, "Draw Vertex Normals", "Displays vertex normals as lines");
2053         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2054         
2055         prop= RNA_def_property(srna, "show_edge_crease", PROP_BOOLEAN, PROP_NONE);
2056         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWCREASES);
2057         RNA_def_property_ui_text(prop, "Draw Creases", "Displays creases created for subsurf weighting");
2058         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2059         
2060         prop= RNA_def_property(srna, "show_edge_bevel_weight", PROP_BOOLEAN, PROP_NONE);
2061         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWBWEIGHTS);
2062         RNA_def_property_ui_text(prop, "Draw Bevel Weights", "Displays weights created for the Bevel modifier");
2063         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2064         
2065         prop= RNA_def_property(srna, "show_edge_seams", PROP_BOOLEAN, PROP_NONE);
2066         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSEAMS);
2067         RNA_def_property_ui_text(prop, "Draw Seams", "Displays UV unwrapping seams");
2068         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2069         
2070         prop= RNA_def_property(srna, "show_edge_sharp", PROP_BOOLEAN, PROP_NONE);
2071         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSHARP);
2072         RNA_def_property_ui_text(prop, "Draw Sharp", "Displays sharp edges, used with the EdgeSplit modifier");
2073         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2074
2075         prop= RNA_def_property(srna, "show_extra_edge_length", PROP_BOOLEAN, PROP_NONE);
2076         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_EDGELEN);
2077         RNA_def_property_ui_text(prop, "Edge Length", "Displays selected edge lengths, Using global values when set in the transform panel");
2078         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2079         
2080         prop= RNA_def_property(srna, "show_extra_face_angle", PROP_BOOLEAN, PROP_NONE);
2081         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_FACEANG);
2082         RNA_def_property_ui_text(prop, "Face Angles", "Displays the angles in the selected edges in degrees, Using global values when set in the transform panel");
2083         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2084         
2085         prop= RNA_def_property(srna, "show_extra_face_area", PROP_BOOLEAN, PROP_NONE);
2086         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEXTRA_FACEAREA);
2087         RNA_def_property_ui_text(prop, "Face Area", "Displays the area of selected faces, Using global values when set in the transform panel");
2088         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
2089
2090         /* editflag */
2091         prop= RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
2092         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_X);
2093         RNA_def_property_ui_text(prop, "X Mirror", "X Axis mirror editing");
2094
2095         /*
2096         prop= RNA_def_property(srna, "use_mirror_y", PROP_BOOLEAN, PROP_NONE);
2097         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Y);
2098         RNA_def_property_ui_text(prop, "Y Mirror", "Y Axis mirror editing");
2099
2100         prop= RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
2101         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Z);
2102         RNA_def_property_ui_text(prop, "Z Mirror", "Z Axis mirror editing");
2103          */
2104
2105         prop= RNA_def_property(srna, "use_mirror_topology", PROP_BOOLEAN, PROP_NONE);
2106         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_TOPO);
2107         RNA_def_property_ui_text(prop, "Topology Mirror", "Use topology based mirroring. For when both sides of mesh have matching, unique topology");
2108
2109         prop= RNA_def_property(srna, "use_paint_mask", PROP_BOOLEAN, PROP_NONE);
2110         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_PAINT_MASK);
2111         RNA_def_property_ui_text(prop, "Paint Mask", "Face selection masking for painting");
2112         RNA_def_property_ui_icon(prop, ICON_FACESEL_HLT, 0);
2113         RNA_def_property_update(prop, 0, "rna_Mesh_update_facemask");
2114
2115         
2116         prop= RNA_def_property(srna, "use_paint_mask_vertex", PROP_BOOLEAN, PROP_NONE);
2117         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_VERT_SEL);
2118         RNA_def_property_ui_text(prop, "Vertex Selection", "Vertex selection masking for painting (weight paint only)");
2119         RNA_def_property_ui_icon(prop, ICON_VERTEXSEL, 0);
2120         RNA_def_property_update(prop, 0, "rna_Mesh_update_vertmask");
2121
2122         /* readonly editmesh info - use for extrude menu */
2123         prop= RNA_def_property(srna, "total_vert_sel", PROP_INT, PROP_UNSIGNED);
2124         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_vert_get", NULL, NULL);
2125         RNA_def_property_ui_text(prop, "Selected Vert Total", "Selected vertex count in editmode");
2126         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2127
2128         prop= RNA_def_property(srna, "total_edge_sel", PROP_INT, PROP_UNSIGNED);
2129         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_edge_get", NULL, NULL);
2130         RNA_def_property_ui_text(prop, "Selected Edge Total", "Selected edge count in editmode");
2131         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2132
2133         prop= RNA_def_property(srna, "total_face_sel", PROP_INT, PROP_UNSIGNED);
2134         RNA_def_property_int_funcs(prop, "rna_Mesh_tot_face_get", NULL, NULL);
2135         RNA_def_property_ui_text(prop, "Selected Face Total", "Selected face count in editmode");
2136         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2137
2138         /* pointers */
2139         rna_def_animdata_common(srna);
2140         rna_def_texmat_common(srna, "rna_Mesh_texspace_editable");
2141
2142         RNA_api_mesh(srna);
2143 }
2144
2145 void RNA_def_mesh(BlenderRNA *brna)
2146 {
2147         rna_def_mesh(brna);
2148         rna_def_mvert(brna);
2149         rna_def_mvert_group(brna);
2150         rna_def_medge(brna);
2151         rna_def_mface(brna);
2152         rna_def_mloop(brna);
2153         rna_def_mpolygon(brna);
2154         rna_def_mtexpoly(brna);
2155         rna_def_msticky(brna);
2156         rna_def_mloopcol(brna);
2157         rna_def_mproperties(brna);
2158 }
2159
2160 #endif
2161