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