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