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