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