merge with trunk/2.5 at r24378
[blender-staging.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /*note: the original vertex color stuff is now just used for
26   getting info on the layers themselves, accessing the data is
27   done through the (not yet written) mpoly interfaces.*/
28
29 #include <stdlib.h>
30
31 #include "RNA_define.h"
32 #include "RNA_types.h"
33
34 #include "rna_internal.h"
35
36 #include "DNA_material_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_meshdata_types.h"
39 #include "DNA_object_types.h"
40
41 #ifdef RNA_RUNTIME
42
43 #include "DNA_scene_types.h"
44
45 #include "BLI_editVert.h"
46 #include "BLI_arithb.h"
47
48 #include "BKE_customdata.h"
49 #include "BKE_depsgraph.h"
50 #include "BKE_main.h"
51 #include "BKE_mesh.h"
52 #include "BKE_utildefines.h"
53 #include "BKE_tessmesh.h"
54
55 #include "WM_api.h"
56 #include "WM_types.h"
57
58 static void rna_Mesh_update_data(bContext *C, PointerRNA *ptr)
59 {
60         ID *id= ptr->id.data;
61
62         DAG_id_flush_update(id, OB_RECALC_DATA);
63         WM_event_add_notifier(C, NC_GEOM|ND_DATA, id);
64 }
65
66 static void rna_Mesh_update_select(bContext *C, PointerRNA *ptr)
67 {
68         ID *id= ptr->id.data;
69
70         WM_event_add_notifier(C, NC_GEOM|ND_SELECT, id);
71 }
72
73 void rna_Mesh_update_draw(bContext *C, PointerRNA *ptr)
74 {
75         ID *id= ptr->id.data;
76
77         WM_event_add_notifier(C, NC_GEOM|ND_DATA, id);
78 }
79
80 static void rna_MeshVertex_normal_get(PointerRNA *ptr, float *value)
81 {
82         MVert *mvert= (MVert*)ptr->data;
83
84         value[0]= mvert->no[0]/32767.0f;
85         value[1]= mvert->no[1]/32767.0f;
86         value[2]= mvert->no[2]/32767.0f;
87 }
88
89 static float rna_MeshVertex_bevel_weight_get(PointerRNA *ptr)
90 {
91         MVert *mvert= (MVert*)ptr->data;
92         return mvert->bweight/255.0f;
93 }
94
95 static void rna_MeshVertex_bevel_weight_set(PointerRNA *ptr, float value)
96 {
97         MVert *mvert= (MVert*)ptr->data;
98         mvert->bweight= (char)(CLAMPIS(value*255.0f, 0, 255));
99 }
100
101 static float rna_MEdge_bevel_weight_get(PointerRNA *ptr)
102 {
103         MEdge *medge= (MEdge*)ptr->data;
104         return medge->bweight/255.0f;
105 }
106
107 static void rna_MEdge_bevel_weight_set(PointerRNA *ptr, float value)
108 {
109         MEdge *medge= (MEdge*)ptr->data;
110         medge->bweight= (char)(CLAMPIS(value*255.0f, 0, 255));
111 }
112
113 static float rna_MEdge_crease_get(PointerRNA *ptr)
114 {
115         MEdge *medge= (MEdge*)ptr->data;
116         return medge->crease/255.0f;
117 }
118
119 static void rna_MEdge_crease_set(PointerRNA *ptr, float value)
120 {
121         MEdge *medge= (MEdge*)ptr->data;
122         medge->crease= (char)(CLAMPIS(value*255.0f, 0, 255));
123 }
124
125 static void rna_MeshFace_normal_get(PointerRNA *ptr, float *values)
126 {
127         Mesh *me= (Mesh*)ptr->id.data;
128         MFace *mface= (MFace*)ptr->data;
129         
130         if(mface->v4)
131                 CalcNormFloat4(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co, me->mvert[mface->v4].co, values);
132         else
133                 CalcNormFloat(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co, values);
134 }
135
136 static float rna_MeshFace_area_get(PointerRNA *ptr)
137 {
138         Mesh *me= (Mesh*)ptr->id.data;
139         MFace *mface= (MFace*)ptr->data;
140
141         if(mface->v4)
142                 return AreaQ3Dfl(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co, me->mvert[mface->v4].co);
143         else
144                 return AreaT3Dfl(me->mvert[mface->v1].co, me->mvert[mface->v2].co, me->mvert[mface->v3].co);
145 }
146
147 /* notice red and blue are swapped */
148 static void rna_MeshColor_color1_get(PointerRNA *ptr, float *values)
149 {
150         MCol *mcol= (MCol*)ptr->data;
151
152         values[2]= (&mcol[0].r)[0]/255.0f;
153         values[1]= (&mcol[0].r)[1]/255.0f;
154         values[0]= (&mcol[0].r)[2]/255.0f;
155 }
156
157 static void rna_MeshColor_color1_set(PointerRNA *ptr, const float *values)
158 {
159         MCol *mcol= (MCol*)ptr->data;
160
161         (&mcol[0].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
162         (&mcol[0].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
163         (&mcol[0].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
164 }
165
166 static void rna_MeshColor_color2_get(PointerRNA *ptr, float *values)
167 {
168         MCol *mcol= (MCol*)ptr->data;
169
170         values[2]= (&mcol[1].r)[0]/255.0f;
171         values[1]= (&mcol[1].r)[1]/255.0f;
172         values[0]= (&mcol[1].r)[2]/255.0f;
173 }
174
175 static void rna_MeshColor_color2_set(PointerRNA *ptr, const float *values)
176 {
177         MCol *mcol= (MCol*)ptr->data;
178
179         (&mcol[1].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
180         (&mcol[1].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
181         (&mcol[1].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
182 }
183
184 static void rna_MeshColor_color3_get(PointerRNA *ptr, float *values)
185 {
186         MCol *mcol= (MCol*)ptr->data;
187
188         values[2]= (&mcol[2].r)[0]/255.0f;
189         values[1]= (&mcol[2].r)[1]/255.0f;
190         values[0]= (&mcol[2].r)[2]/255.0f;
191 }
192
193 static void rna_MeshColor_color3_set(PointerRNA *ptr, const float *values)
194 {
195         MCol *mcol= (MCol*)ptr->data;
196
197         (&mcol[2].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
198         (&mcol[2].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
199         (&mcol[2].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
200 }
201
202 static void rna_MeshColor_color4_get(PointerRNA *ptr, float *values)
203 {
204         MCol *mcol= (MCol*)ptr->data;
205
206         values[2]= (&mcol[3].r)[0]/255.0f;
207         values[1]= (&mcol[3].r)[1]/255.0f;
208         values[0]= (&mcol[3].r)[2]/255.0f;
209 }
210
211 static void rna_MeshColor_color4_set(PointerRNA *ptr, const float *values)
212 {
213         MCol *mcol= (MCol*)ptr->data;
214
215         (&mcol[3].r)[2]= (char)(CLAMPIS(values[0]*255.0f, 0, 255));
216         (&mcol[3].r)[1]= (char)(CLAMPIS(values[1]*255.0f, 0, 255));
217         (&mcol[3].r)[0]= (char)(CLAMPIS(values[2]*255.0f, 0, 255));
218 }
219
220 static int rna_Mesh_texspace_editable(PointerRNA *ptr)
221 {
222         Mesh *me= (Mesh*)ptr->data;
223         return (me->texflag & AUTOSPACE)? 0: PROP_EDITABLE;
224 }
225
226 static void rna_MeshVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
227 {
228         Mesh *me= (Mesh*)ptr->id.data;
229
230         if(me->dvert) {
231                 MVert *mvert= (MVert*)ptr->data;
232                 MDeformVert *dvert= me->dvert + (mvert-me->mvert);
233
234                 rna_iterator_array_begin(iter, (void*)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
235         }
236         else
237                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
238 }
239
240 static void rna_MeshFace_material_index_range(PointerRNA *ptr, int *min, int *max)
241 {
242         Mesh *me= (Mesh*)ptr->id.data;
243         *min= 0;
244         *max= me->totcol-1;
245 }
246
247 static CustomData *rna_mesh_pdata(Mesh *me)
248 {
249         return (me->edit_btmesh)? &me->edit_btmesh->bm->pdata: &me->pdata;
250 }
251
252 static CustomData *rna_mesh_ldata(Mesh *me)
253 {
254         return (me->edit_btmesh)? &me->edit_btmesh->bm->ldata: &me->ldata;
255 }
256
257 static int rna_CustomDataLayer_length(PointerRNA *ptr, int type)
258 {
259         Mesh *me= (Mesh*)ptr->id.data;
260         CustomData *fdata= rna_mesh_pdata(me);
261         CustomDataLayer *layer;
262         int i, length= 0;
263
264         for(layer=fdata->layers, i=0; i<fdata->totlayer; layer++, i++)
265                 if(layer->type == type)
266                         length++;
267
268         return length;
269 }
270
271 static int rna_CustomDataLayer_active_get(PointerRNA *ptr, int type, int render)
272 {
273         Mesh *me= (Mesh*)ptr->id.data;
274         CustomData *fdata= rna_mesh_pdata(me);
275         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
276
277         if(render) return (n == CustomData_get_render_layer_index(fdata, type));
278         else return (n == CustomData_get_active_layer_index(fdata, type));
279 }
280
281 static void rna_CustomDataLayer_active_set(PointerRNA *ptr, int value, int type, int render)
282 {
283         Mesh *me= (Mesh*)ptr->id.data;
284         CustomData *fdata= rna_mesh_pdata(me);
285         int n= ((CustomDataLayer*)ptr->data) - fdata->layers;
286
287         if(value == 0)
288                 return;
289
290         if(render) CustomData_set_layer_render_index(fdata, type, n);
291         else CustomData_set_layer_active_index(fdata, type, n);
292 }
293
294 static int rna_uv_texture_check(CollectionPropertyIterator *iter, void *data)
295 {
296         CustomDataLayer *layer= (CustomDataLayer*)data;
297         return (layer->type != CD_MTEXPOLY);
298 }
299
300 static void rna_Mesh_uv_textures_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
301 {
302         Mesh *me= (Mesh*)ptr->data;
303         CustomData *fdata= rna_mesh_pdata(me);
304         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_uv_texture_check);
305 }
306
307 static int rna_Mesh_uv_textures_length(PointerRNA *ptr)
308 {
309         return rna_CustomDataLayer_length(ptr, CD_MTEXPOLY);
310 }
311
312 static PointerRNA rna_Mesh_active_uv_texture_get(PointerRNA *ptr)
313 {
314         Mesh *me= (Mesh*)ptr->data;
315         CustomData *fdata= rna_mesh_pdata(me);
316         int index= CustomData_get_active_layer_index(fdata, CD_MTEXPOLY);
317         CustomDataLayer *cdl= (index == -1)? NULL: &fdata->layers[index];
318
319         return rna_pointer_inherit_refine(ptr, &RNA_MeshTextureFaceLayer, cdl);
320 }
321
322 static void rna_Mesh_active_uv_texture_set(PointerRNA *ptr, PointerRNA value)
323 {
324         Mesh *me= (Mesh*)ptr->data;
325         CustomData *fdata= rna_mesh_pdata(me);
326         CustomDataLayer *cdl;
327         int a;
328
329         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
330                 if(value.data == cdl) {
331                         CustomData_set_layer_active_index(fdata, CD_MTEXPOLY, a);
332                         mesh_update_customdata_pointers(me);
333                         return;
334                 }
335         }
336 }
337
338 static int rna_Mesh_active_uv_texture_index_get(PointerRNA *ptr)
339 {
340         Mesh *me= (Mesh*)ptr->data;
341         CustomData *fdata= rna_mesh_pdata(me);
342         return CustomData_get_active_layer(fdata, CD_MTEXPOLY);
343 }
344
345 static void rna_Mesh_active_uv_texture_index_set(PointerRNA *ptr, int value)
346 {
347         Mesh *me= (Mesh*)ptr->data;
348         CustomData *fdata= rna_mesh_pdata(me);
349
350         CustomData_set_layer_active(fdata, CD_MTEXPOLY, value);
351         mesh_update_customdata_pointers(me);
352 }
353
354 static void rna_Mesh_active_uv_texture_index_range(PointerRNA *ptr, int *min, int *max)
355 {
356         Mesh *me= (Mesh*)ptr->data;
357         CustomData *pdata= rna_mesh_pdata(me);
358
359         *min= 0;
360         *max= CustomData_number_of_layers(pdata, CD_MTEXPOLY)-1;
361         *max= MAX2(0, *max);
362 }
363
364 static void rna_MeshTextureFace_uv1_get(PointerRNA *ptr, float *values)
365 {
366         MLoopUV *mloopuv= (MLoopUV*)ptr->data;
367         
368         values[0]= mloopuv->uv[0];
369         values[1]= mloopuv->uv[1];
370 }
371
372 static void rna_MeshTextureFace_uv1_set(PointerRNA *ptr, const float *values)
373 {
374         MLoopUV *mloopuv= (MLoopUV*)ptr->data;
375         
376         mloopuv->uv[0] = values[0];
377         mloopuv->uv[1] = values[1];
378 }
379
380 static int rna_CustomDataData_numverts(PointerRNA *ptr, int type)
381 {
382         /*BMESH_TODO
383         Mesh *me= (Mesh*)ptr->id.data;
384         CustomData *fdata= rna_mesh_fdata(me);
385         CustomDataLayer *cdl;
386         int a;
387         size_t b;
388
389         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
390                 if(cdl->type == type) {
391                         b= ((char*)ptr->data - ((char*)cdl->data))/CustomData_sizeof(type);
392                         if(b >= 0 && b < me->totface)
393                                 return (me->mface[b].v4? 4: 3);
394                 }
395         }
396
397         return 0;*/
398         return 0;
399 }
400
401 static int rna_MeshTextureFace_uv_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
402 {
403         //return rna_CustomDataData_numverts(ptr, CD_MTFACE) * 2;
404         return 0; //BMESH_TODO
405 }
406
407 static void rna_MeshTextureFace_uv_get(PointerRNA *ptr, float *values)
408 {
409         //MTFace *mtface= (MTFace*)ptr->data;
410         //int totvert= rna_CustomDataData_numverts(ptr, CD_MTFACE);
411
412         //memcpy(values, mtface->uv, totvert * 2 * sizeof(float));
413 }
414
415 static void rna_MeshTextureFace_uv_set(PointerRNA *ptr, const float *values)
416 {
417         //MTFace *mtface= (MTFace*)ptr->data;
418         //int totvert= rna_CustomDataData_numverts(ptr, CD_MTFACE);
419
420         //memcpy(mtface->uv, values, totvert * 2 * sizeof(float));
421 }
422
423 static void rna_MeshTextureFaceLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
424 {
425         Mesh *me= (Mesh*)ptr->id.data;
426         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
427         rna_iterator_array_begin(iter, layer->data, sizeof(MTexPoly), me->totpoly, 0, NULL);
428 }
429
430 static int rna_MeshTextureFaceLayer_data_length(PointerRNA *ptr)
431 {
432         Mesh *me= (Mesh*)ptr->id.data;
433         return me->totpoly;
434 }
435
436 static int rna_MeshTextureFaceLayer_active_render_get(PointerRNA *ptr)
437 {
438         return rna_CustomDataLayer_active_get(ptr, CD_MTEXPOLY, 1);
439 }
440
441 static int rna_MeshTextureFaceLayer_active_get(PointerRNA *ptr)
442 {
443         return rna_CustomDataLayer_active_get(ptr, CD_MTEXPOLY, 0);
444 }
445
446 static void rna_MeshTextureFaceLayer_active_render_set(PointerRNA *ptr, int value)
447 {
448         rna_CustomDataLayer_active_set(ptr, value, CD_MTEXPOLY, 1);
449 }
450
451 static void rna_MeshTextureFaceLayer_active_set(PointerRNA *ptr, int value)
452 {
453         rna_CustomDataLayer_active_set(ptr, value, CD_MTEXPOLY, 0);
454 }
455
456 static void rna_MeshTextureFaceLayer_name_set(PointerRNA *ptr, const char *value)
457 {
458         Mesh *me= (Mesh*)ptr->id.data;
459         CustomData *fdata= rna_mesh_pdata(me);
460         CustomDataLayer *cdl= (CustomDataLayer*)ptr->data;
461         BLI_strncpy(cdl->name, value, sizeof(cdl->name));
462         CustomData_set_layer_unique_name(&me->pdata, cdl - rna_mesh_pdata(me)->layers);
463 }
464
465 static int rna_vertex_color_check(CollectionPropertyIterator *iter, void *data)
466 {
467         CustomDataLayer *layer= (CustomDataLayer*)data;
468         return (layer->type != CD_MLOOPCOL);
469 }
470
471 static void rna_Mesh_vertex_colors_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
472 {
473         Mesh *me= (Mesh*)ptr->data;
474         CustomData *ldata= rna_mesh_ldata(me);
475         rna_iterator_array_begin(iter, (void*)ldata->layers, sizeof(CustomDataLayer), ldata->totlayer, 0, rna_vertex_color_check);
476 }
477
478 static int rna_Mesh_vertex_colors_length(PointerRNA *ptr)
479 {
480         return rna_CustomDataLayer_length(ptr, CD_MLOOPCOL);
481 }
482
483 static PointerRNA rna_Mesh_active_vertex_color_get(PointerRNA *ptr)
484 {
485         Mesh *me= (Mesh*)ptr->data;
486         CustomData *ldata= rna_mesh_ldata(me);
487         int index= CustomData_get_active_layer_index(ldata, CD_MLOOPCOL);
488         CustomDataLayer *cdl= (index == -1)? NULL: &ldata->layers[index];
489
490         return rna_pointer_inherit_refine(ptr, &RNA_MeshColorLayer, cdl);
491 }
492
493 static void rna_Mesh_active_vertex_color_set(PointerRNA *ptr, PointerRNA value)
494 {
495         Mesh *me= (Mesh*)ptr->data;
496         CustomData *ldata= rna_mesh_ldata(me), *fdata;
497         CustomDataLayer *cdl;
498         int a, b, c;
499
500         b = 0;
501         for(cdl=ldata->layers, a=0; a<ldata->totlayer; cdl++, a++) {
502                 if (cdl->type == CD_MLOOPCOL)
503                         b++;
504
505                 if(value.data == cdl) {
506                         CustomData_set_layer_active_index(ldata, CD_MLOOPCOL, a);
507                         break;
508                 }
509         }
510
511         mesh_update_customdata_pointers(me);
512 }
513
514 static int rna_Mesh_active_vertex_color_index_get(PointerRNA *ptr)
515 {
516         Mesh *me= (Mesh*)ptr->data;
517         CustomData *ldata= rna_mesh_ldata(me);
518         return CustomData_get_active_layer(ldata, CD_MLOOPCOL);
519 }
520
521 static void rna_Mesh_active_vertex_color_index_set(PointerRNA *ptr, int value)
522 {
523         Mesh *me= (Mesh*)ptr->data;
524         CustomData *ldata= rna_mesh_ldata(me);
525
526         CustomData_set_layer_active(ldata, CD_MLOOPCOL, value);
527         mesh_update_customdata_pointers(me);
528 }
529
530 static void rna_Mesh_active_vertex_color_index_range(PointerRNA *ptr, int *min, int *max)
531 {
532         Mesh *me= (Mesh*)ptr->data;
533         CustomData *ldata= rna_mesh_ldata(me);
534
535         *min= 0;
536         *max= CustomData_number_of_layers(ldata, CD_MLOOPCOL)-1;
537         *max= MAX2(0, *max);
538 }
539
540 static void rna_MeshColorLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
541 {
542         Mesh *me= (Mesh*)ptr->id.data;
543         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
544         rna_iterator_array_begin(iter, layer->data, sizeof(CD_MLOOPCOL), me->totloop, 0, NULL);
545 }
546
547 static int rna_MeshColorLayer_data_length(PointerRNA *ptr)
548 {
549         Mesh *me= (Mesh*)ptr->id.data;
550         return me->totloop;
551 }
552
553 static int rna_MeshColorLayer_active_render_get(PointerRNA *ptr)
554 {
555         return rna_CustomDataLayer_active_get(ptr, CD_MLOOPCOL, 1);
556 }
557
558 static int rna_MeshColorLayer_active_get(PointerRNA *ptr)
559 {
560         return rna_CustomDataLayer_active_get(ptr, CD_MLOOPCOL, 0);
561 }
562
563 static void rna_MeshColorLayer_active_render_set(PointerRNA *ptr, int value)
564 {
565         rna_CustomDataLayer_active_set(ptr, value, CD_MLOOPCOL, 1);
566 }
567
568 static void rna_MeshColorLayer_active_set(PointerRNA *ptr, int value)
569 {
570         rna_CustomDataLayer_active_set(ptr, value, CD_MLOOPCOL, 0);
571 }
572
573 static void rna_MeshColorLayer_name_set(PointerRNA *ptr, const char *value)
574 {
575         Mesh *me= (Mesh*)ptr->id.data;
576         CustomData *fdata= rna_mesh_pdata(me);
577         CustomDataLayer *cdl= (CustomDataLayer*)ptr->data;
578         BLI_strncpy(cdl->name, value, sizeof(cdl->name));
579         CustomData_set_layer_unique_name(&me->ldata, cdl - rna_mesh_pdata(me)->layers);
580 }
581
582 static void rna_MeshFloatPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
583 {
584         Mesh *me= (Mesh*)ptr->id.data;
585         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
586         rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totface, 0, NULL);
587 }
588
589 static int rna_MeshFloatPropertyLayer_data_length(PointerRNA *ptr)
590 {
591         Mesh *me= (Mesh*)ptr->id.data;
592         return me->totface;
593 }
594
595 static int rna_float_layer_check(CollectionPropertyIterator *iter, void *data)
596 {
597         CustomDataLayer *layer= (CustomDataLayer*)data;
598         return (layer->type != CD_PROP_FLT);
599 }
600
601 static void rna_Mesh_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
602 {
603         Mesh *me= (Mesh*)ptr->data;
604         CustomData *fdata= rna_mesh_pdata(me);
605         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_float_layer_check);
606 }
607
608 static int rna_Mesh_float_layers_length(PointerRNA *ptr)
609 {
610         return rna_CustomDataLayer_length(ptr, CD_PROP_FLT);
611 }
612
613 static int rna_int_layer_check(CollectionPropertyIterator *iter, void *data)
614 {
615         CustomDataLayer *layer= (CustomDataLayer*)data;
616         return (layer->type != CD_PROP_INT);
617 }
618
619 static void rna_MeshIntPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
620 {
621         Mesh *me= (Mesh*)ptr->id.data;
622         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
623         rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totface, 0, NULL);
624 }
625
626 static int rna_MeshIntPropertyLayer_data_length(PointerRNA *ptr)
627 {
628         Mesh *me= (Mesh*)ptr->id.data;
629         return me->totface;
630 }
631
632 static void rna_Mesh_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
633 {
634         Mesh *me= (Mesh*)ptr->data;
635         CustomData *fdata= rna_mesh_pdata(me);
636         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_int_layer_check);
637 }
638
639 static int rna_Mesh_int_layers_length(PointerRNA *ptr)
640 {
641         return rna_CustomDataLayer_length(ptr, CD_PROP_INT);
642 }
643
644 static int rna_string_layer_check(CollectionPropertyIterator *iter, void *data)
645 {
646         CustomDataLayer *layer= (CustomDataLayer*)data;
647         return (layer->type != CD_PROP_STR);
648 }
649
650 static void rna_MeshStringPropertyLayer_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
651 {
652         Mesh *me= (Mesh*)ptr->id.data;
653         CustomDataLayer *layer= (CustomDataLayer*)ptr->data;
654         rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totface, 0, NULL);
655 }
656
657 static int rna_MeshStringPropertyLayer_data_length(PointerRNA *ptr)
658 {
659         Mesh *me= (Mesh*)ptr->id.data;
660         return me->totface;
661 }
662
663 static void rna_Mesh_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
664 {
665         Mesh *me= (Mesh*)ptr->data;
666         CustomData *fdata= rna_mesh_pdata(me);
667         rna_iterator_array_begin(iter, (void*)fdata->layers, sizeof(CustomDataLayer), fdata->totlayer, 0, rna_string_layer_check);
668 }
669
670 static int rna_Mesh_string_layers_length(PointerRNA *ptr)
671 {
672         return rna_CustomDataLayer_length(ptr, CD_PROP_STR);
673 }
674
675 static void rna_TextureFace_image_set(PointerRNA *ptr, PointerRNA value)
676 {
677         MTexPoly *tf= (MTexPoly*)ptr->data;
678         ID *id= value.data;
679
680         if(id) {
681                 /* special exception here, individual faces don't count
682                  * as reference, but we do ensure the refcount is not zero */
683                 if(id->us == 0)
684                         id_us_plus(id);
685                 else
686                         id_lib_extern(id);
687         }
688
689         tf->tpage= (struct Image*)id;
690 }
691
692 static int rna_MeshFace_verts_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
693 {
694         MFace *face= (MFace*)ptr->data;
695
696         if(face)
697                 length[0]= (face->v4)? 4: 3;
698         else
699                 length[0]= 4; // XXX rna_raw_access wants the length of a dummy face. this needs fixing. - Campbell
700
701         return length[0];
702 }
703
704 static void rna_MeshFace_verts_get(PointerRNA *ptr, int *values)
705 {
706         MFace *face= (MFace*)ptr->data;
707         memcpy(values, &face->v1, (face->v4 ? 4 : 3) * sizeof(int));
708 }
709
710 static void rna_MeshFace_verts_set(PointerRNA *ptr, const int *values)
711 {
712         MFace *face= (MFace*)ptr->data;
713         memcpy(&face->v1, values, (face->v4 ? 4 : 3) * sizeof(int));
714 }
715
716 static int rna_MeshVertex_index_get(PointerRNA *ptr)
717 {
718         Mesh *me= (Mesh*)ptr->id.data;
719         MVert *vert= (MVert*)ptr->data;
720         return (int)(vert - me->mvert);
721 }
722
723 static int rna_MeshEdge_index_get(PointerRNA *ptr)
724 {
725         Mesh *me= (Mesh*)ptr->id.data;
726         MEdge *edge= (MEdge*)ptr->data;
727         return (int)(edge - me->medge);
728 }
729
730 static int rna_MeshFace_index_get(PointerRNA *ptr)
731 {
732         Mesh *me= (Mesh*)ptr->id.data;
733         MFace *face= (MFace*)ptr->data;
734         return (int)(face - me->mface);
735 }
736
737 /* path construction */
738
739 static char *rna_VertexGroupElement_path(PointerRNA *ptr)
740 {
741         Mesh *me= (Mesh*)ptr->id.data; /* XXX not always! */
742         MDeformWeight *dw= (MDeformWeight*)ptr->data;
743         MDeformVert *dvert;
744         int a, b;
745         
746         for(a=0, dvert=me->dvert; a<me->totvert; a++, dvert++)
747                 for(b=0; b<dvert->totweight; b++)
748                         if(dw == &dvert->dw[b])
749                                 return BLI_sprintfN("verts[%d].groups[%d]", a, b);
750
751         return NULL;
752 }
753
754 static char *rna_MeshFace_path(PointerRNA *ptr)
755 {
756         return BLI_sprintfN("faces[%d]", (MFace*)ptr->data - ((Mesh*)ptr->id.data)->mface);
757 }
758
759 static char *rna_MeshEdge_path(PointerRNA *ptr)
760 {
761         return BLI_sprintfN("edges[%d]", (MEdge*)ptr->data - ((Mesh*)ptr->id.data)->medge);
762 }
763
764 static char *rna_MeshVertex_path(PointerRNA *ptr)
765 {
766         return BLI_sprintfN("verts[%d]", (MVert*)ptr->data - ((Mesh*)ptr->id.data)->mvert);
767 }
768
769 static char *rna_MeshTextureFaceLayer_path(PointerRNA *ptr)
770 {
771         return BLI_sprintfN("uv_textures[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
772 }
773
774 static char *rna_CustomDataData_path(PointerRNA *ptr, char *collection, int type)
775 {
776         Mesh *me= (Mesh*)ptr->id.data;
777         CustomData *fdata= rna_mesh_pdata(me);
778         CustomDataLayer *cdl;
779         int a;
780         size_t b;
781
782         for(cdl=fdata->layers, a=0; a<fdata->totlayer; cdl++, a++) {
783                 if(cdl->type == type) {
784                         b= ((char*)ptr->data - ((char*)cdl->data))/CustomData_sizeof(type);
785                         if(b >= 0 && b < me->totface)
786                                 return BLI_sprintfN("%s[\"%s\"].data[%d]", collection, cdl->name, b);
787                 }
788         }
789
790         return NULL;
791 }
792
793 static char *rna_MeshTextureFace_path(PointerRNA *ptr)
794 {
795         return rna_CustomDataData_path(ptr, "uv_textures", CD_MTEXPOLY);
796 }
797
798 static char *rna_MeshColorLayer_path(PointerRNA *ptr)
799 {
800         return BLI_sprintfN("vertex_colors[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
801 }
802
803 static char *rna_MeshColor_path(PointerRNA *ptr)
804 {
805         return rna_CustomDataData_path(ptr, "vertex_colors", CD_MLOOPCOL);
806 }
807
808 static char *rna_MeshSticky_path(PointerRNA *ptr)
809 {
810         return BLI_sprintfN("sticky[%d]", (MSticky*)ptr->data - ((Mesh*)ptr->id.data)->msticky);
811 }
812
813 static char *rna_MeshIntPropertyLayer_path(PointerRNA *ptr)
814 {
815         return BLI_sprintfN("int_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
816 }
817
818 static char *rna_MeshIntProperty_path(PointerRNA *ptr)
819 {
820         return rna_CustomDataData_path(ptr, "int_layers", CD_MCOL);
821 }
822
823 static char *rna_MeshFloatPropertyLayer_path(PointerRNA *ptr)
824 {
825         return BLI_sprintfN("float_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
826 }
827
828 static char *rna_MeshFloatProperty_path(PointerRNA *ptr)
829 {
830         return rna_CustomDataData_path(ptr, "float_layers", CD_MCOL);
831 }
832
833 static char *rna_MeshStringPropertyLayer_path(PointerRNA *ptr)
834 {
835         return BLI_sprintfN("string_layers[\"%s\"]", ((CustomDataLayer*)ptr->data)->name);
836 }
837
838 static char *rna_MeshStringProperty_path(PointerRNA *ptr)
839 {
840         return rna_CustomDataData_path(ptr, "string_layers", CD_MCOL);
841 }
842
843 #else
844
845 static void rna_def_mvert_group(BlenderRNA *brna)
846 {
847         StructRNA *srna;
848         PropertyRNA *prop;
849
850         srna= RNA_def_struct(brna, "VertexGroupElement", NULL);
851         RNA_def_struct_sdna(srna, "MDeformWeight");
852         RNA_def_struct_path_func(srna, "rna_VertexGroupElement_path");
853         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group.");
854         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
855
856         /* we can't point to actual group, it is in the object and so
857          * there is no unique group to point to, hence the index */
858         prop= RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
859         RNA_def_property_int_sdna(prop, NULL, "def_nr");
860         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
861         RNA_def_property_ui_text(prop, "Group Index", "");
862         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
863
864         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
865         RNA_def_property_range(prop, 0.0f, 1.0f);
866         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
867         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
868 }
869
870 static void rna_def_mvert(BlenderRNA *brna)
871 {
872         StructRNA *srna;
873         PropertyRNA *prop;
874
875         srna= RNA_def_struct(brna, "MeshVertex", NULL);
876         RNA_def_struct_sdna(srna, "MVert");
877         RNA_def_struct_ui_text(srna, "Mesh Vertex", "Vertex in a Mesh datablock.");
878         RNA_def_struct_path_func(srna, "rna_MeshVertex_path");
879         RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
880
881         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
882         RNA_def_property_ui_text(prop, "Location", "");
883         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
884
885         prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
886         RNA_def_property_float_sdna(prop, NULL, "no");
887         RNA_def_property_float_funcs(prop, "rna_MeshVertex_normal_get", NULL, NULL);
888         RNA_def_property_ui_text(prop, "Normal", "Vertex Normal");
889         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
890
891         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
892         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
893         RNA_def_property_ui_text(prop, "Selected", "");
894         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
895
896         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
897         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
898         RNA_def_property_ui_text(prop, "Hidden", "");
899         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
900
901         prop= RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
902         RNA_def_property_float_funcs(prop, "rna_MeshVertex_bevel_weight_get", "rna_MeshVertex_bevel_weight_set", NULL);
903         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier 'Only Vertices' option");
904         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
905
906         prop= RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
907         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, 0, 0);
908         RNA_def_property_struct_type(prop, "VertexGroupElement");
909         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of.");
910
911         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
912         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
913         RNA_def_property_int_funcs(prop, "rna_MeshVertex_index_get", NULL, NULL);
914         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex.");
915 }
916
917 static void rna_def_medge(BlenderRNA *brna)
918 {
919         StructRNA *srna;
920         PropertyRNA *prop;
921
922         srna= RNA_def_struct(brna, "MeshEdge", NULL);
923         RNA_def_struct_sdna(srna, "MEdge");
924         RNA_def_struct_ui_text(srna, "Mesh Edge", "Edge in a Mesh datablock.");
925         RNA_def_struct_path_func(srna, "rna_MeshEdge_path");
926         RNA_def_struct_ui_icon(srna, ICON_EDGESEL);
927
928         prop= RNA_def_property(srna, "verts", PROP_INT, PROP_UNSIGNED);
929         RNA_def_property_int_sdna(prop, NULL, "v1");
930         RNA_def_property_array(prop, 2);
931         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
932         // XXX allows creating invalid meshes
933
934         prop= RNA_def_property(srna, "crease", PROP_FLOAT, PROP_NONE);
935         RNA_def_property_float_funcs(prop, "rna_MEdge_crease_get", "rna_MEdge_crease_set", NULL);
936         RNA_def_property_ui_text(prop, "Crease", "Weight used by the Subsurf modifier for creasing");
937         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
938
939         prop= RNA_def_property(srna, "bevel_weight", PROP_FLOAT, PROP_NONE);
940         RNA_def_property_float_funcs(prop, "rna_MEdge_bevel_weight_get", "rna_MEdge_bevel_weight_set", NULL);
941         RNA_def_property_ui_text(prop, "Bevel Weight", "Weight used by the Bevel modifier");
942         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
943
944         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
945         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
946         RNA_def_property_ui_text(prop, "Selected", "");
947         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
948
949         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
950         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
951         RNA_def_property_ui_text(prop, "Hidden", "");
952         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
953
954         prop= RNA_def_property(srna, "seam", PROP_BOOLEAN, PROP_NONE);
955         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SEAM);
956         RNA_def_property_ui_text(prop, "Seam", "Seam edge for UV unwrapping");
957         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
958
959         prop= RNA_def_property(srna, "sharp", PROP_BOOLEAN, PROP_NONE);
960         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SHARP);
961         RNA_def_property_ui_text(prop, "Sharp", "Sharp edge for the EdgeSplit modifier");
962         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
963
964         prop= RNA_def_property(srna, "loose", PROP_BOOLEAN, PROP_NONE);
965         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_LOOSEEDGE);
966         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
967         RNA_def_property_ui_text(prop, "Loose", "Loose edge");
968
969         prop= RNA_def_property(srna, "fgon", PROP_BOOLEAN, PROP_NONE);
970         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FGON);
971         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
972         RNA_def_property_ui_text(prop, "Fgon", "Fgon edge");
973
974         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
975         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
976         RNA_def_property_int_funcs(prop, "rna_MeshEdge_index_get", NULL, NULL);
977         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex.");
978 }
979
980 static void rna_def_mface(BlenderRNA *brna)
981 {
982         StructRNA *srna;
983         PropertyRNA *prop;
984
985         srna= RNA_def_struct(brna, "MeshFace", NULL);
986         RNA_def_struct_sdna(srna, "MFace");
987         RNA_def_struct_ui_text(srna, "Mesh Face", "Face in a Mesh datablock.");
988         RNA_def_struct_path_func(srna, "rna_MeshFace_path");
989         RNA_def_struct_ui_icon(srna, ICON_FACESEL);
990
991         // XXX allows creating invalid meshes
992         prop= RNA_def_property(srna, "verts", PROP_INT, PROP_UNSIGNED);
993         RNA_def_property_array(prop, 4);
994         RNA_def_property_flag(prop, PROP_DYNAMIC);
995         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshFace_verts_get_length");
996         RNA_def_property_int_funcs(prop, "rna_MeshFace_verts_get", "rna_MeshFace_verts_set", NULL);
997         RNA_def_property_ui_text(prop, "Vertices", "Vertex indices");
998
999         /* leaving this fixed size array for foreach_set used in import scripts */
1000         prop= RNA_def_property(srna, "verts_raw", PROP_INT, PROP_UNSIGNED);
1001         RNA_def_property_int_sdna(prop, NULL, "v1");
1002         RNA_def_property_array(prop, 4);
1003         RNA_def_property_ui_text(prop, "Vertices", "Fixed size vertex indices array");
1004
1005         prop= RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1006         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1007         RNA_def_property_ui_text(prop, "Material Index", "");
1008         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MeshFace_material_index_range");
1009         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1010
1011         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
1012         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FACE_SEL);
1013         RNA_def_property_ui_text(prop, "Selected", "");
1014         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1015
1016         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
1017         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_HIDE);
1018         RNA_def_property_ui_text(prop, "Hidden", "");
1019         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1020
1021         prop= RNA_def_property(srna, "smooth", PROP_BOOLEAN, PROP_NONE);
1022         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
1023         RNA_def_property_ui_text(prop, "Smooth", "");
1024         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1025         
1026         prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
1027         RNA_def_property_array(prop, 3);
1028         RNA_def_property_range(prop, -1.0f, 1.0f);
1029         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1030         RNA_def_property_float_funcs(prop, "rna_MeshFace_normal_get", NULL, NULL);
1031         RNA_def_property_ui_text(prop, "face normal", "local space unit length normal vector for this face");
1032
1033         prop= RNA_def_property(srna, "area", PROP_FLOAT, PROP_UNSIGNED);
1034         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1035         RNA_def_property_float_funcs(prop, "rna_MeshFace_area_get", NULL, NULL);
1036         RNA_def_property_ui_text(prop, "face area", "read only area of the face");
1037
1038         prop= RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1039         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1040         RNA_def_property_int_funcs(prop, "rna_MeshFace_index_get", NULL, NULL);
1041         RNA_def_property_ui_text(prop, "Index", "Index number of the vertex.");
1042 }
1043
1044 static void rna_def_mtexpoly(BlenderRNA *brna)
1045 {
1046         StructRNA *srna;
1047         PropertyRNA *prop;
1048         static const EnumPropertyItem transp_items[]= {
1049                 {TF_SOLID, "OPAQUE", 0, "Opaque", "Render color of textured face as color"},
1050                 {TF_ADD, "ADD", 0, "Add", "Render face transparent and add color of face"},
1051                 {TF_ALPHA, "ALPHA", 0, "Alpha", "Render polygon transparent, depending on alpha channel of the texture"},
1052                 {TF_CLIP, "CLIPALPHA", 0, "Clip Alpha", "Use the images alpha values clipped with no blending (binary alpha)"},
1053                 {0, NULL, 0, NULL, NULL}};
1054         int uv_dim[]= {4, 2};
1055
1056         srna= RNA_def_struct(brna, "MeshTextureFaceLayer", NULL);
1057         RNA_def_struct_ui_text(srna, "Mesh Texture Face Layer", "Layer of texture faces in a Mesh datablock.");
1058         RNA_def_struct_sdna(srna, "CustomDataLayer");
1059         RNA_def_struct_path_func(srna, "rna_MeshTextureFaceLayer_path");
1060         RNA_def_struct_ui_icon(srna, ICON_GROUP_UVS);
1061
1062         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1063         RNA_def_struct_name_property(srna, prop);
1064         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshTextureFaceLayer_name_set");
1065         RNA_def_property_ui_text(prop, "Name", "");
1066         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1067
1068         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1069         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_get", "rna_MeshTextureFaceLayer_active_set");
1070         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1071         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1072
1073         prop= RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1074         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1075         RNA_def_property_boolean_funcs(prop, "rna_MeshTextureFaceLayer_active_render_get", "rna_MeshTextureFaceLayer_active_render_set");
1076         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1077         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1078
1079         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1080         RNA_def_property_struct_type(prop, "MeshTextureFace");
1081         RNA_def_property_ui_text(prop, "Data", "");
1082         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, 0, 0);
1083
1084         srna= RNA_def_struct(brna, "MeshTextureFace", NULL);
1085         RNA_def_struct_sdna(srna, "MTexPoly");
1086         RNA_def_struct_ui_text(srna, "Mesh Texture Face", "UV mapping, texturing and game engine data for a face.");
1087         RNA_def_struct_path_func(srna, "rna_MeshTextureFace_path");
1088         RNA_def_struct_ui_icon(srna, ICON_FACESEL_HLT);
1089
1090         prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1091         RNA_def_property_pointer_sdna(prop, NULL, "tpage");
1092         RNA_def_property_pointer_funcs(prop, NULL, "rna_TextureFace_image_set", NULL);
1093         RNA_def_property_flag(prop, PROP_EDITABLE);
1094         RNA_def_property_ui_text(prop, "Image", "");
1095         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1096
1097         prop= RNA_def_property(srna, "tex", PROP_BOOLEAN, PROP_NONE);
1098         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TEX);
1099         RNA_def_property_ui_text(prop, "Tex", "Render face with texture");
1100         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1101
1102         prop= RNA_def_property(srna, "light", PROP_BOOLEAN, PROP_NONE);
1103         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_LIGHT);
1104         RNA_def_property_ui_text(prop, "Light", "Use light for face");
1105         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1106         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1107
1108         prop= RNA_def_property(srna, "invisible", PROP_BOOLEAN, PROP_NONE);
1109         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_INVISIBLE);
1110         RNA_def_property_ui_text(prop, "Invisible", "Make face invisible");
1111         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1112
1113         prop= RNA_def_property(srna, "collision", PROP_BOOLEAN, PROP_NONE);
1114         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_DYNAMIC);
1115         RNA_def_property_ui_text(prop, "Collision", "Use face for collision and ray-sensor detection");
1116         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1117
1118         prop= RNA_def_property(srna, "shared", PROP_BOOLEAN, PROP_NONE);
1119         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_SHAREDCOL);
1120         RNA_def_property_ui_text(prop, "Shared", "Blend vertex colors across face when vertices are shared");
1121         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1122
1123         prop= RNA_def_property(srna, "twoside", PROP_BOOLEAN, PROP_NONE);
1124         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TWOSIDE);
1125         RNA_def_property_ui_text(prop, "Twoside", "Render face twosided");
1126         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1127
1128         prop= RNA_def_property(srna, "object_color", PROP_BOOLEAN, PROP_NONE);
1129         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_OBCOL);
1130         RNA_def_property_ui_text(prop, "Object Color", "Use ObColor instead of vertex colors");
1131         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1132
1133         prop= RNA_def_property(srna, "halo", PROP_BOOLEAN, PROP_NONE);
1134         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_BILLBOARD);
1135         RNA_def_property_ui_text(prop, "Halo", "Screen aligned billboard");
1136         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1137
1138         prop= RNA_def_property(srna, "billboard", PROP_BOOLEAN, PROP_NONE);
1139         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_BILLBOARD2);
1140         RNA_def_property_ui_text(prop, "Billboard", "Billboard with Z-axis constraint");
1141         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1142
1143         prop= RNA_def_property(srna, "shadow", PROP_BOOLEAN, PROP_NONE);
1144         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_SHADOW);
1145         RNA_def_property_ui_text(prop, "Shadow", "Face is used for shadow");
1146         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1147
1148         prop= RNA_def_property(srna, "text", PROP_BOOLEAN, PROP_NONE);
1149         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_BMFONT);
1150         RNA_def_property_ui_text(prop, "Text", "Enable bitmap text on face");
1151         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1152
1153         prop= RNA_def_property(srna, "alpha_sort", PROP_BOOLEAN, PROP_NONE);
1154         RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_ALPHASORT);
1155         RNA_def_property_ui_text(prop, "Alpha Sort", "Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)");
1156         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1157
1158         prop= RNA_def_property(srna, "transp", PROP_ENUM, PROP_NONE);
1159         RNA_def_property_enum_items(prop, transp_items);
1160         RNA_def_property_ui_text(prop, "Transparency", "Transparency blending mode");
1161         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1162
1163         prop= RNA_def_property(srna, "uv_selected", PROP_BOOLEAN, PROP_NONE);
1164         RNA_def_property_boolean_sdna(prop, NULL, "flag", TF_SEL1);
1165         RNA_def_property_array(prop, 4);
1166         RNA_def_property_ui_text(prop, "UV Selected", "");
1167         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1168
1169         prop= RNA_def_property(srna, "uv_pinned", PROP_BOOLEAN, PROP_NONE);
1170         RNA_def_property_boolean_sdna(prop, NULL, "unwrap", TF_PIN1);
1171         RNA_def_property_array(prop, 4);
1172         RNA_def_property_ui_text(prop, "UV Pinned", "");
1173         RNA_def_property_update(prop, 0, "rna_Mesh_update_select");
1174
1175         prop= RNA_def_property(srna, "uv", PROP_FLOAT, PROP_NONE);
1176         RNA_def_property_multi_array(prop, 2, uv_dim);
1177         RNA_def_property_flag(prop, PROP_DYNAMIC);
1178         RNA_def_property_dynamic_array_funcs(prop, "rna_MeshTextureFace_uv_get_length");
1179         RNA_def_property_float_funcs(prop, "rna_MeshTextureFace_uv_get", "rna_MeshTextureFace_uv_set", NULL);
1180         RNA_def_property_ui_text(prop, "UV", "");
1181         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1182 }
1183
1184 static void rna_def_msticky(BlenderRNA *brna)
1185 {
1186         StructRNA *srna;
1187         PropertyRNA *prop;
1188
1189         srna= RNA_def_struct(brna, "MeshSticky", NULL);
1190         RNA_def_struct_sdna(srna, "MSticky");
1191         RNA_def_struct_ui_text(srna, "Mesh Vertex Sticky Texture Coordinate", "Stricky texture coordinate.");
1192         RNA_def_struct_path_func(srna, "rna_MeshSticky_path");
1193
1194         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
1195         RNA_def_property_ui_text(prop, "Location", "Sticky texture coordinate location.");
1196         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1197 }
1198
1199 static void rna_def_mloopcol(BlenderRNA *brna)
1200 {
1201         StructRNA *srna;
1202         PropertyRNA *prop;
1203
1204         srna= RNA_def_struct(brna, "MeshColorLayer", NULL);
1205         RNA_def_struct_ui_text(srna, "Mesh Vertex Color Layer", "Layer of vertex colors in a Mesh datablock.");
1206         RNA_def_struct_sdna(srna, "CustomDataLayer");
1207         RNA_def_struct_path_func(srna, "rna_MeshColorLayer_path");
1208         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
1209
1210         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1211         RNA_def_struct_name_property(srna, prop);
1212         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshColorLayer_name_set");
1213         RNA_def_property_ui_text(prop, "Name", "");
1214         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1215
1216         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1217         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_get", "rna_MeshColorLayer_active_set");
1218         RNA_def_property_ui_text(prop, "Active", "Sets the layer as active for display and editing");
1219         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1220
1221         prop= RNA_def_property(srna, "active_render", PROP_BOOLEAN, PROP_NONE);
1222         RNA_def_property_boolean_sdna(prop, NULL, "active_rnd", 0);
1223         RNA_def_property_boolean_funcs(prop, "rna_MeshColorLayer_active_render_get", "rna_MeshColorLayer_active_render_set");
1224         RNA_def_property_ui_text(prop, "Active Render", "Sets the layer as active for rendering");
1225
1226         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1227
1228         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1229         RNA_def_property_struct_type(prop, "MeshColor");
1230         RNA_def_property_ui_text(prop, "Data", "");
1231         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, 0, 0);
1232
1233         srna= RNA_def_struct(brna, "MeshColor", NULL);
1234         RNA_def_struct_sdna(srna, "MCol");
1235         RNA_def_struct_ui_text(srna, "Mesh Vertex Color", "Vertex colors for a face in a Mesh.");
1236         RNA_def_struct_path_func(srna, "rna_MeshColor_path");
1237
1238         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1239 }
1240
1241 static void rna_def_mproperties(BlenderRNA *brna)
1242 {
1243         StructRNA *srna;
1244         PropertyRNA *prop;
1245
1246         /* Float */
1247         srna= RNA_def_struct(brna, "MeshFloatPropertyLayer", NULL);
1248         RNA_def_struct_sdna(srna, "CustomDataLayer");
1249         RNA_def_struct_ui_text(srna, "Mesh Float Property Layer", "User defined layer of floating pointer number values.");
1250         RNA_def_struct_path_func(srna, "rna_MeshFloatPropertyLayer_path");
1251
1252         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1253         RNA_def_struct_name_property(srna, prop);
1254         RNA_def_property_ui_text(prop, "Name", "");
1255         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1256
1257         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1258         RNA_def_property_struct_type(prop, "MeshFloatProperty");
1259         RNA_def_property_ui_text(prop, "Data", "");
1260         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, 0, 0);
1261
1262         srna= RNA_def_struct(brna, "MeshFloatProperty", NULL);
1263         RNA_def_struct_sdna(srna, "MFloatProperty");
1264         RNA_def_struct_ui_text(srna, "Mesh Float Property", "User defined floating point number value in a float properties layer.");
1265         RNA_def_struct_path_func(srna, "rna_MeshFloatProperty_path");
1266
1267         prop= RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
1268         RNA_def_property_float_sdna(prop, NULL, "f");
1269         RNA_def_property_ui_text(prop, "Value", "");
1270         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1271
1272         /* Int */
1273         srna= RNA_def_struct(brna, "MeshIntPropertyLayer", NULL);
1274         RNA_def_struct_sdna(srna, "CustomDataLayer");
1275         RNA_def_struct_ui_text(srna, "Mesh Int Property Layer", "User defined layer of integer number values.");
1276         RNA_def_struct_path_func(srna, "rna_MeshIntPropertyLayer_path");
1277
1278         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1279         RNA_def_struct_name_property(srna, prop);
1280         RNA_def_property_ui_text(prop, "Name", "");
1281         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1282
1283         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1284         RNA_def_property_struct_type(prop, "MeshIntProperty");
1285         RNA_def_property_ui_text(prop, "Data", "");
1286         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, 0, 0);
1287
1288         srna= RNA_def_struct(brna, "MeshIntProperty", NULL);
1289         RNA_def_struct_sdna(srna, "MIntProperty");
1290         RNA_def_struct_ui_text(srna, "Mesh Int Property", "User defined integer number value in an integer properties layer.");
1291         RNA_def_struct_path_func(srna, "rna_MeshIntProperty_path");
1292
1293         prop= RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
1294         RNA_def_property_int_sdna(prop, NULL, "i");
1295         RNA_def_property_ui_text(prop, "Value", "");
1296         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1297
1298         /* String */
1299         srna= RNA_def_struct(brna, "MeshStringPropertyLayer", NULL);
1300         RNA_def_struct_sdna(srna, "CustomDataLayer");
1301         RNA_def_struct_ui_text(srna, "Mesh String Property Layer", "User defined layer of string text values.");
1302         RNA_def_struct_path_func(srna, "rna_MeshStringPropertyLayer_path");
1303
1304         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1305         RNA_def_struct_name_property(srna, prop);
1306         RNA_def_property_ui_text(prop, "Name", "");
1307         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1308
1309         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
1310         RNA_def_property_struct_type(prop, "MeshStringProperty");
1311         RNA_def_property_ui_text(prop, "Data", "");
1312         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, 0, 0);
1313
1314         srna= RNA_def_struct(brna, "MeshStringProperty", NULL);
1315         RNA_def_struct_sdna(srna, "MStringProperty");
1316         RNA_def_struct_ui_text(srna, "Mesh String Property", "User defined string text value in a string properties layer.");
1317         RNA_def_struct_path_func(srna, "rna_MeshStringProperty_path");
1318
1319         prop= RNA_def_property(srna, "value", PROP_STRING, PROP_NONE);
1320         RNA_def_property_string_sdna(prop, NULL, "s");
1321         RNA_def_property_ui_text(prop, "Value", "");
1322         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1323 }
1324
1325 void rna_def_texmat_common(StructRNA *srna, const char *texspace_editable)
1326 {
1327         PropertyRNA *prop;
1328
1329         /* texture space */
1330         prop= RNA_def_property(srna, "auto_texspace", PROP_BOOLEAN, PROP_NONE);
1331         RNA_def_property_boolean_sdna(prop, NULL, "texflag", AUTOSPACE);
1332         RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjusts active object's texture space automatically when transforming object.");
1333
1334         prop= RNA_def_property(srna, "texspace_loc", PROP_FLOAT, PROP_TRANSLATION);
1335         RNA_def_property_float_sdna(prop, NULL, "loc");
1336         RNA_def_property_ui_text(prop, "Texure Space Location", "Texture space location.");
1337         RNA_def_property_editable_func(prop, texspace_editable);
1338         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1339
1340         prop= RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
1341         RNA_def_property_float_sdna(prop, NULL, "size");
1342         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size.");
1343         RNA_def_property_editable_func(prop, texspace_editable);
1344         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1345
1346         /* not supported yet
1347         prop= RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
1348         RNA_def_property_float(prop, NULL, "rot");
1349         RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
1350         RNA_def_property_editable_func(prop, texspace_editable);
1351         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");*/
1352
1353         /* materials */
1354         prop= RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1355         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1356         RNA_def_property_struct_type(prop, "Material");
1357         RNA_def_property_ui_text(prop, "Materials", "");
1358 }
1359
1360 static void rna_def_mesh(BlenderRNA *brna)
1361 {
1362         StructRNA *srna;
1363         PropertyRNA *prop;
1364
1365         srna= RNA_def_struct(brna, "Mesh", "ID");
1366         RNA_def_struct_ui_text(srna, "Mesh", "Mesh datablock to define geometric surfaces.");
1367         RNA_def_struct_ui_icon(srna, ICON_MESH_DATA);
1368
1369         prop= RNA_def_property(srna, "verts", PROP_COLLECTION, PROP_NONE);
1370         RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert");
1371         RNA_def_property_struct_type(prop, "MeshVertex");
1372         RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh.");
1373
1374         prop= RNA_def_property(srna, "edges", PROP_COLLECTION, PROP_NONE);
1375         RNA_def_property_collection_sdna(prop, NULL, "medge", "totedge");
1376         RNA_def_property_struct_type(prop, "MeshEdge");
1377         RNA_def_property_ui_text(prop, "Edges", "Edges of the mesh.");
1378
1379         prop= RNA_def_property(srna, "faces", PROP_COLLECTION, PROP_NONE);
1380         RNA_def_property_collection_sdna(prop, NULL, "mface", "totface");
1381         RNA_def_property_struct_type(prop, "MeshFace");
1382         RNA_def_property_ui_text(prop, "Faces", "Faces of the mesh.");
1383
1384         prop= RNA_def_property(srna, "sticky", PROP_COLLECTION, PROP_NONE);
1385         RNA_def_property_collection_sdna(prop, NULL, "msticky", "totvert");
1386         RNA_def_property_struct_type(prop, "MeshSticky");
1387         RNA_def_property_ui_text(prop, "Sticky", "Sticky texture coordinates.");
1388
1389         /* TODO, should this be allowed to be its self? */
1390         prop= RNA_def_property(srna, "texture_mesh", PROP_POINTER, PROP_NONE);
1391         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
1392         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
1393         RNA_def_property_ui_text(prop, "Texture Mesh", "Use another mesh for texture indicies (vertex indicies must be aligned).");
1394
1395         /* UV textures */
1396         prop= RNA_def_property(srna, "uv_textures", PROP_COLLECTION, PROP_NONE);
1397         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1398         RNA_def_property_collection_funcs(prop, "rna_Mesh_uv_textures_begin", 0, 0, 0, "rna_Mesh_uv_textures_length", 0, 0, 0, 0);
1399         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1400         RNA_def_property_ui_text(prop, "UV Textures", "");
1401
1402         prop= RNA_def_property(srna, "active_uv_texture", PROP_POINTER, PROP_UNSIGNED);
1403         RNA_def_property_struct_type(prop, "MeshTextureFaceLayer");
1404         RNA_def_property_pointer_funcs(prop, "rna_Mesh_active_uv_texture_get", "rna_Mesh_active_uv_texture_set", NULL);
1405         RNA_def_property_flag(prop, PROP_EDITABLE);
1406         RNA_def_property_ui_text(prop, "Active UV Texture", "Active UV texture.");
1407         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1408
1409         prop= RNA_def_property(srna, "active_uv_texture_index", PROP_INT, PROP_UNSIGNED);
1410         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");
1411         RNA_def_property_ui_text(prop, "Active UV Texture Index", "Active UV texture index.");
1412         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1413
1414         /* Vertex colors */
1415
1416         prop= RNA_def_property(srna, "vertex_colors", PROP_COLLECTION, PROP_NONE);
1417         RNA_def_property_collection_sdna(prop, NULL, "ldata.layers", "ldata.totlayer");
1418         RNA_def_property_collection_funcs(prop, "rna_Mesh_vertex_colors_begin", 0, 0, 0, "rna_Mesh_vertex_colors_length", 0, 0, 0, 0);
1419         RNA_def_property_struct_type(prop, "MeshColorLayer");
1420         RNA_def_property_ui_text(prop, "Vertex Colors", "");
1421
1422         prop= RNA_def_property(srna, "active_vertex_color", PROP_POINTER, PROP_UNSIGNED);
1423         RNA_def_property_struct_type(prop, "MeshColorLayer");
1424         RNA_def_property_pointer_funcs(prop, "rna_Mesh_active_vertex_color_get", "rna_Mesh_active_vertex_color_set", NULL);
1425         RNA_def_property_flag(prop, PROP_EDITABLE);
1426         RNA_def_property_ui_text(prop, "Active Vertex Color Layer", "Active vertex color layer.");
1427         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1428
1429         prop= RNA_def_property(srna, "active_vertex_color_index", PROP_INT, PROP_UNSIGNED);
1430         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");
1431         RNA_def_property_ui_text(prop, "Active Vertex Color Index", "Active vertex color index.");
1432         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1433
1434         prop= RNA_def_property(srna, "float_layers", PROP_COLLECTION, PROP_NONE);
1435         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1436         RNA_def_property_collection_funcs(prop, "rna_Mesh_float_layers_begin", 0, 0, 0, "rna_Mesh_float_layers_length", 0, 0, 0, 0);
1437         RNA_def_property_struct_type(prop, "MeshFloatPropertyLayer");
1438         RNA_def_property_ui_text(prop, "Float Property Layers", "");
1439
1440         prop= RNA_def_property(srna, "int_layers", PROP_COLLECTION, PROP_NONE);
1441         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1442         RNA_def_property_collection_funcs(prop, "rna_Mesh_int_layers_begin", 0, 0, 0, "rna_Mesh_int_layers_length", 0, 0, 0, 0);
1443         RNA_def_property_struct_type(prop, "MeshIntPropertyLayer");
1444         RNA_def_property_ui_text(prop, "Int Property Layers", "");
1445
1446         prop= RNA_def_property(srna, "string_layers", PROP_COLLECTION, PROP_NONE);
1447         RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
1448         RNA_def_property_collection_funcs(prop, "rna_Mesh_string_layers_begin", 0, 0, 0, "rna_Mesh_string_layers_length", 0, 0, 0, 0);
1449         RNA_def_property_struct_type(prop, "MeshStringPropertyLayer");
1450         RNA_def_property_ui_text(prop, "String Property Layers", "");
1451
1452         prop= RNA_def_property(srna, "autosmooth", PROP_BOOLEAN, PROP_NONE);
1453         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_AUTOSMOOTH);
1454         RNA_def_property_ui_text(prop, "Auto Smooth", "Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render");
1455
1456         prop= RNA_def_property(srna, "autosmooth_angle", PROP_INT, PROP_NONE);
1457         RNA_def_property_int_sdna(prop, NULL, "smoothresh");
1458         RNA_def_property_range(prop, 1, 80);
1459         RNA_def_property_ui_text(prop, "Auto Smooth Angle", "Defines maximum angle between face normals that 'Auto Smooth' will operate on");
1460
1461         prop= RNA_def_property(srna, "vertex_normal_flip", PROP_BOOLEAN, PROP_NONE);
1462         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ME_NOPUNOFLIP);
1463         RNA_def_property_ui_text(prop, "Vertex Normal Flip", "Flip vertex normals towards the camera during render");
1464
1465         prop= RNA_def_property(srna, "double_sided", PROP_BOOLEAN, PROP_NONE);
1466         RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_TWOSIDED);
1467         RNA_def_property_ui_text(prop, "Double Sided", "Render/display the mesh with double or single sided lighting");
1468         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1469
1470         prop= RNA_def_property(srna, "texco_mesh", PROP_POINTER, PROP_NONE);
1471         RNA_def_property_pointer_sdna(prop, NULL, "texcomesh");
1472         RNA_def_property_flag(prop, PROP_EDITABLE);
1473         RNA_def_property_ui_text(prop, "Texture Space Mesh", "Derive texture coordinates from another mesh");
1474
1475         prop= RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
1476         RNA_def_property_pointer_sdna(prop, NULL, "key");
1477         RNA_def_property_ui_text(prop, "Shape Keys", "");
1478
1479         /* Mesh Draw Options for Edit Mode*/
1480         
1481         prop= RNA_def_property(srna, "draw_edges", PROP_BOOLEAN, PROP_NONE);
1482         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWEDGES);
1483         RNA_def_property_ui_text(prop, "Draw Edges", "Displays selected edges using hilights in the 3d view and UV editor");
1484         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1485         
1486         prop= RNA_def_property(srna, "all_edges", PROP_BOOLEAN, PROP_NONE);
1487         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_ALLEDGES);
1488         RNA_def_property_ui_text(prop, "All Edges", "Displays all edges for wireframe in all view modes in the 3d view");
1489
1490         prop= RNA_def_property(srna, "draw_faces", PROP_BOOLEAN, PROP_NONE);
1491         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWFACES);
1492         RNA_def_property_ui_text(prop, "Draw Faces", "Displays all faces as shades in the 3d view and UV editor");
1493         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1494         
1495         prop= RNA_def_property(srna, "draw_normals", PROP_BOOLEAN, PROP_NONE);
1496         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWNORMALS);
1497         RNA_def_property_ui_text(prop, "Draw Normals", "Displays face normals as lines");
1498         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1499         
1500         prop= RNA_def_property(srna, "draw_vertex_normals", PROP_BOOLEAN, PROP_NONE);
1501         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_VNORMALS);
1502         RNA_def_property_ui_text(prop, "Draw Vertex Normals", "Displays vertex normals as lines");
1503         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1504         
1505         prop= RNA_def_property(srna, "draw_creases", PROP_BOOLEAN, PROP_NONE);
1506         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWCREASES);
1507         RNA_def_property_ui_text(prop, "Draw Creases", "Displays creases created for subsurf weighting");
1508         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1509         
1510         prop= RNA_def_property(srna, "draw_bevel_weights", PROP_BOOLEAN, PROP_NONE);
1511         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWBWEIGHTS);
1512         RNA_def_property_ui_text(prop, "Draw Bevel Weights", "Displays weights created for the Bevel modifier");
1513         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1514         
1515         prop= RNA_def_property(srna, "draw_seams", PROP_BOOLEAN, PROP_NONE);
1516         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSEAMS);
1517         RNA_def_property_ui_text(prop, "Draw Seams", "Displays UV unwrapping seams");
1518         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1519         
1520         prop= RNA_def_property(srna, "draw_sharp", PROP_BOOLEAN, PROP_NONE);
1521         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAWSHARP);
1522         RNA_def_property_ui_text(prop, "Draw Sharp", "Displays sharp edges, used with the EdgeSplit modifier");
1523         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1524         
1525         prop= RNA_def_property(srna, "draw_edge_lenght", PROP_BOOLEAN, PROP_NONE);
1526         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_EDGELEN);
1527         RNA_def_property_ui_text(prop, "Edge Length", "Displays selected edge lengths");
1528         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1529         
1530         prop= RNA_def_property(srna, "draw_edge_angle", PROP_BOOLEAN, PROP_NONE);
1531         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_EDGEANG);
1532         RNA_def_property_ui_text(prop, "Edge Angles", "Displays the angles in the selected edges in degrees");
1533         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1534         
1535         prop= RNA_def_property(srna, "draw_face_area", PROP_BOOLEAN, PROP_NONE);
1536         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_FACEAREA);
1537         RNA_def_property_ui_text(prop, "Face Area", "Displays the area of selected faces");
1538         RNA_def_property_update(prop, 0, "rna_Mesh_update_draw");
1539
1540         prop= RNA_def_property(srna, "draw_pins", PROP_BOOLEAN, PROP_NONE);
1541         RNA_def_property_boolean_sdna(prop, NULL, "drawflag", ME_DRAW_PINS);
1542         RNA_def_property_ui_text(prop, "Draw Pins", "Displays pinned mesh elements");
1543         RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
1544         /* editflag */
1545         prop= RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
1546         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_X);
1547         RNA_def_property_ui_text(prop, "X Mirror", "X Axis mirror editing");
1548
1549         /*
1550         prop= RNA_def_property(srna, "use_mirror_y", PROP_BOOLEAN, PROP_NONE);
1551         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Y);
1552         RNA_def_property_ui_text(prop, "Y Mirror", "Y Axis mirror editing");
1553
1554         prop= RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
1555         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_MIRROR_Z);
1556         RNA_def_property_ui_text(prop, "Z Mirror", "Z Axis mirror editing");
1557          */
1558
1559         prop= RNA_def_property(srna, "use_paint_mask", PROP_BOOLEAN, PROP_NONE);
1560         RNA_def_property_boolean_sdna(prop, NULL, "editflag", ME_EDIT_PAINT_MASK);
1561         RNA_def_property_ui_text(prop, "Paint Mask", "Face selection masking for painting");
1562
1563
1564
1565         rna_def_texmat_common(srna, "rna_Mesh_texspace_editable");
1566
1567         RNA_api_mesh(srna);
1568 }
1569
1570 void RNA_def_mesh(BlenderRNA *brna)
1571 {
1572         rna_def_mesh(brna);
1573         rna_def_mvert(brna);
1574         rna_def_mvert_group(brna);
1575         rna_def_medge(brna);
1576         rna_def_mface(brna);
1577         rna_def_mtexpoly(brna);
1578         rna_def_msticky(brna);
1579         rna_def_mloopcol(brna);
1580         rna_def_mproperties(brna);
1581 }
1582
1583 #endif
1584