svn merge ^/trunk/blender -r42333:42361
[blender.git] / source / blender / blenkernel / intern / DerivedMesh.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/DerivedMesh.c
29  *  \ingroup bke
30  */
31
32
33 #include <string.h>
34 #include "limits.h"
35
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_cloth_types.h"
39 #include "DNA_key_types.h"
40 #include "DNA_meshdata_types.h"
41 #include "DNA_armature_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_scene_types.h" // N_T
44
45 #include "BLI_blenlib.h"
46 #include "BLI_editVert.h"
47 #include "BLI_math.h"
48 #include "BLI_memarena.h"
49 #include "BLI_array.h"
50 #include "BLI_pbvh.h"
51 #include "BLI_utildefines.h"
52 #include "BLI_linklist.h"
53
54 #include "BKE_cdderivedmesh.h"
55 #include "BKE_displist.h"
56 #include "BKE_key.h"
57 #include "BKE_modifier.h"
58 #include "BKE_mesh.h"
59 #include "BKE_object.h"
60 #include "BKE_paint.h"
61 #include "BKE_texture.h"
62 #include "BKE_multires.h"
63 #include "BKE_armature.h"
64 #include "BKE_particle.h"
65 #include "BKE_tessmesh.h"
66 #include "BKE_bvhutils.h"
67
68 #ifdef WITH_GAMEENGINE
69 #include "BKE_navmesh_conversion.h"
70 static DerivedMesh *navmesh_dm_createNavMeshForVisualization(DerivedMesh *dm);
71 #endif
72
73 #include "BLO_sys_types.h" // for intptr_t support
74
75 #include "GL/glew.h"
76
77 #include "GPU_buffers.h"
78 #include "GPU_draw.h"
79 #include "GPU_extensions.h"
80 #include "GPU_material.h"
81
82 extern GLubyte stipple_quarttone[128]; /* glutil.c, bad level data */
83
84 static void add_shapekey_layers(DerivedMesh *dm, Mesh *me, Object *ob);
85 static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid);
86
87 ///////////////////////////////////
88 ///////////////////////////////////
89
90 static MVert *dm_getVertArray(DerivedMesh *dm)
91 {
92         MVert *mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
93
94         if (!mvert) {
95                 mvert = CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL,
96                         dm->getNumVerts(dm));
97                 CustomData_set_layer_flag(&dm->vertData, CD_MVERT, CD_FLAG_TEMPORARY);
98                 dm->copyVertArray(dm, mvert);
99         }
100
101         return mvert;
102 }
103
104 static MEdge *dm_getEdgeArray(DerivedMesh *dm)
105 {
106         MEdge *medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
107
108         if (!medge) {
109                 medge = CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL,
110                         dm->getNumEdges(dm));
111                 CustomData_set_layer_flag(&dm->edgeData, CD_MEDGE, CD_FLAG_TEMPORARY);
112                 dm->copyEdgeArray(dm, medge);
113         }
114
115         return medge;
116 }
117
118 static MFace *dm_getTessFaceArray(DerivedMesh *dm)
119 {
120         MFace *mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
121
122         if (!mface) {
123                 mface = CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL,
124                         dm->getNumTessFaces(dm));
125                 CustomData_set_layer_flag(&dm->faceData, CD_MFACE, CD_FLAG_TEMPORARY);
126                 dm->copyTessFaceArray(dm, mface);
127         }
128
129         return mface;
130 }
131
132 static MLoop *dm_getLoopArray(DerivedMesh *dm)
133 {
134         MLoop *mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
135
136         if (!mloop) {
137                 mloop = CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL,
138                         dm->numLoopData);
139                 CustomData_set_layer_flag(&dm->loopData, CD_MLOOP, CD_FLAG_TEMPORARY);
140                 dm->copyLoopArray(dm, mloop);
141         }
142
143         return mloop;
144 }
145
146 static MPoly *dm_getPolyArray(DerivedMesh *dm)
147 {
148         MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
149
150         if (!mpoly) {
151                 mpoly = CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL,
152                         dm->getNumPolys(dm));
153                 CustomData_set_layer_flag(&dm->polyData, CD_MPOLY, CD_FLAG_TEMPORARY);
154                 dm->copyPolyArray(dm, mpoly);
155         }
156
157         return mpoly;
158 }
159
160 static MVert *dm_dupVertArray(DerivedMesh *dm)
161 {
162         MVert *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumVerts(dm),
163                                                          "dm_dupVertArray tmp");
164
165         if(tmp) dm->copyVertArray(dm, tmp);
166
167         return tmp;
168 }
169
170 static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
171 {
172         MEdge *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumEdges(dm),
173                                                          "dm_dupEdgeArray tmp");
174
175         if(tmp) dm->copyEdgeArray(dm, tmp);
176
177         return tmp;
178 }
179
180 static MFace *dm_dupFaceArray(DerivedMesh *dm)
181 {
182         MFace *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumTessFaces(dm),
183                                                          "dm_dupFaceArray tmp");
184
185         if(tmp) dm->copyTessFaceArray(dm, tmp);
186
187         return tmp;
188 }
189
190 static MLoop *dm_dupLoopArray(DerivedMesh *dm)
191 {
192         MLoop *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumLoops(dm),
193                                                          "dm_dupLoopArray tmp");
194
195         if(tmp) dm->copyLoopArray(dm, tmp);
196
197         return tmp;
198 }
199
200 static MPoly *dm_dupPolyArray(DerivedMesh *dm)
201 {
202         MPoly *tmp = MEM_callocN(sizeof(*tmp) * dm->getNumPolys(dm),
203                                                          "dm_dupPolyArray tmp");
204
205         if(tmp) dm->copyPolyArray(dm, tmp);
206
207         return tmp;
208 }
209
210 static CustomData *dm_getVertCData(DerivedMesh *dm)
211 {
212         return &dm->vertData;
213 }
214
215 static CustomData *dm_getEdgeCData(DerivedMesh *dm)
216 {
217         return &dm->edgeData;
218 }
219
220 static CustomData *dm_getTessFaceCData(DerivedMesh *dm)
221 {
222         return &dm->faceData;
223 }
224
225 static CustomData *dm_getLoopCData(DerivedMesh *dm)
226 {
227         return &dm->loopData;
228 }
229
230 static CustomData *dm_getPolyCData(DerivedMesh *dm)
231 {
232         return &dm->polyData;
233 }
234
235 void DM_init_funcs(DerivedMesh *dm)
236 {
237         /* default function implementations */
238         dm->getVertArray = dm_getVertArray;
239         dm->getEdgeArray = dm_getEdgeArray;
240         dm->getTessFaceArray = dm_getTessFaceArray;
241         dm->getLoopArray = dm_getLoopArray;
242         dm->getPolyArray = dm_getPolyArray;
243         dm->dupVertArray = dm_dupVertArray;
244         dm->dupEdgeArray = dm_dupEdgeArray;
245         dm->dupTessFaceArray = dm_dupFaceArray;
246         dm->dupLoopArray = dm_dupLoopArray;
247         dm->dupPolyArray = dm_dupPolyArray;
248
249         dm->getVertDataLayout = dm_getVertCData;
250         dm->getEdgeDataLayout = dm_getEdgeCData;
251         dm->getTessFaceDataLayout = dm_getTessFaceCData;
252         dm->getLoopDataLayout = dm_getLoopCData;
253         dm->getPolyDataLayout = dm_getPolyCData;
254
255         dm->getVertData = DM_get_vert_data;
256         dm->getEdgeData = DM_get_edge_data;
257         dm->getTessFaceData = DM_get_tessface_data;
258         dm->getVertDataArray = DM_get_vert_data_layer;
259         dm->getEdgeDataArray = DM_get_edge_data_layer;
260         dm->getTessFaceDataArray = DM_get_tessface_data_layer;
261
262         bvhcache_init(&dm->bvhCache);
263 }
264
265 void DM_init(DerivedMesh *dm, DerivedMeshType type, int numVerts, int numEdges,
266              int numTessFaces, int numLoops, int numPolys)
267 {
268         dm->type = type;
269         dm->numVertData = numVerts;
270         dm->numEdgeData = numEdges;
271         dm->numTessFaceData = numTessFaces;
272         dm->numLoopData = numLoops;
273         dm->numPolyData = numPolys;
274
275         DM_init_funcs(dm);
276         
277         dm->needsFree = 1;
278 }
279
280 void DM_from_template(DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
281                       int numVerts, int numEdges, int numTessFaces,
282                       int numLoops, int numPolys)
283 {
284         CustomData_copy(&source->vertData, &dm->vertData, CD_MASK_DERIVEDMESH,
285                                         CD_CALLOC, numVerts);
286         CustomData_copy(&source->edgeData, &dm->edgeData, CD_MASK_DERIVEDMESH,
287                                         CD_CALLOC, numEdges);
288         CustomData_copy(&source->faceData, &dm->faceData, CD_MASK_DERIVEDMESH,
289                                         CD_CALLOC, numTessFaces);
290         CustomData_copy(&source->loopData, &dm->loopData, CD_MASK_DERIVEDMESH,
291                         CD_CALLOC, numLoops);
292         CustomData_copy(&source->polyData, &dm->polyData, CD_MASK_DERIVEDMESH,
293                         CD_CALLOC, numPolys);
294
295         dm->type = type;
296         dm->numVertData = numVerts;
297         dm->numEdgeData = numEdges;
298         dm->numTessFaceData = numTessFaces;
299         dm->numLoopData = numLoops;
300         dm->numPolyData = numPolys;
301
302         DM_init_funcs(dm);
303
304         dm->needsFree = 1;
305 }
306
307 int DM_release(DerivedMesh *dm)
308 {
309         if (dm->needsFree) {
310                 bvhcache_free(&dm->bvhCache);
311                 GPU_drawobject_free( dm );
312                 CustomData_free(&dm->vertData, dm->numVertData);
313                 CustomData_free(&dm->edgeData, dm->numEdgeData);
314                 CustomData_free(&dm->faceData, dm->numTessFaceData);
315                 CustomData_free(&dm->loopData, dm->numLoopData);
316                 CustomData_free(&dm->polyData, dm->numPolyData);
317
318                 return 1;
319         }
320         else {
321                 CustomData_free_temporary(&dm->vertData, dm->numVertData);
322                 CustomData_free_temporary(&dm->edgeData, dm->numEdgeData);
323                 CustomData_free_temporary(&dm->faceData, dm->numTessFaceData);
324                 CustomData_free_temporary(&dm->loopData, dm->numLoopData);
325                 CustomData_free_temporary(&dm->polyData, dm->numPolyData);
326
327                 return 0;
328         }
329 }
330
331 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target)
332 {
333         CustomData_free(&target->loopData, source->numLoopData);
334         CustomData_free(&target->polyData, source->numPolyData);
335
336         CustomData_copy(&source->loopData, &target->loopData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numLoopData);
337         CustomData_copy(&source->polyData, &target->polyData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numPolyData);
338
339         target->numLoopData = source->numLoopData;
340         target->numPolyData = source->numPolyData;
341
342         if (!CustomData_has_layer(&target->polyData, CD_MPOLY)) {
343                 MPoly *mpoly;
344                 MLoop *mloop;
345
346                 mloop = source->dupLoopArray(source);
347                 mpoly = source->dupPolyArray(source);
348                 CustomData_add_layer(&target->loopData, CD_MLOOP, CD_ASSIGN, mloop, source->numLoopData);
349                 CustomData_add_layer(&target->polyData, CD_MPOLY, CD_ASSIGN, mpoly, source->numPolyData);
350         }
351 }
352
353 void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
354 {
355         /* dm might depend on me, so we need to do everything with a local copy */
356         Mesh tmp = *me;
357         int totvert, totedge /*, totface */ /* UNUSED */, totloop, totpoly;
358         int did_shapekeys=0;
359         
360         memset(&tmp.vdata, 0, sizeof(tmp.vdata));
361         memset(&tmp.edata, 0, sizeof(tmp.edata));
362         memset(&tmp.fdata, 0, sizeof(tmp.fdata));
363         memset(&tmp.ldata, 0, sizeof(tmp.ldata));
364         memset(&tmp.pdata, 0, sizeof(tmp.pdata));
365
366         totvert = tmp.totvert = dm->getNumVerts(dm);
367         totedge = tmp.totedge = dm->getNumEdges(dm);
368         totpoly = tmp.totpoly = dm->getNumPolys(dm);
369         totloop = tmp.totloop = dm->numLoopData;
370
371         CustomData_copy(&dm->vertData, &tmp.vdata, CD_MASK_MESH, CD_DUPLICATE, totvert);
372         CustomData_copy(&dm->edgeData, &tmp.edata, CD_MASK_MESH, CD_DUPLICATE, totedge);
373         CustomData_copy(&dm->loopData, &tmp.ldata, CD_MASK_MESH, CD_DUPLICATE, totloop);
374         CustomData_copy(&dm->polyData, &tmp.pdata, CD_MASK_MESH, CD_DUPLICATE, totpoly);
375
376         if (CustomData_has_layer(&dm->vertData, CD_SHAPEKEY)) {
377                 KeyBlock *kb;
378                 int i=0;
379                 
380                 if (ob) {
381                         for (kb=me->key->block.first; kb; kb=kb->next, i++) {
382                                 if (i == ob->shapenr-1) {
383                                         i = kb->uid;
384                                         break;
385                                 }
386                         }
387                         
388                         if (!kb) {
389                                 printf("%s: error - could not find active shapekey %d!\n",
390                                        __func__, ob->shapenr-1);
391
392                                 i = INT_MAX;
393                         }
394                 } else {
395                         /*if no object, set to INT_MAX so we don't mess up any shapekey layers*/
396                         i = INT_MAX;
397                 }
398                 
399                 shapekey_layers_to_keyblocks(dm, me, i);
400                 did_shapekeys = 1;
401         }
402         
403         /* not all DerivedMeshes store their verts/edges/faces in CustomData, so
404            we set them here in case they are missing */
405         if(!CustomData_has_layer(&tmp.vdata, CD_MVERT))
406                 CustomData_add_layer(&tmp.vdata, CD_MVERT, CD_ASSIGN, dm->dupVertArray(dm), totvert);
407         if(!CustomData_has_layer(&tmp.edata, CD_MEDGE))
408                 CustomData_add_layer(&tmp.edata, CD_MEDGE, CD_ASSIGN, dm->dupEdgeArray(dm), totedge);
409         if(!CustomData_has_layer(&tmp.pdata, CD_MPOLY)) {
410                 tmp.mloop = dm->dupLoopArray(dm);
411                 tmp.mpoly = dm->dupPolyArray(dm);
412
413                 CustomData_add_layer(&tmp.ldata, CD_MLOOP, CD_ASSIGN, tmp.mloop, tmp.totloop);
414                 CustomData_add_layer(&tmp.pdata, CD_MPOLY, CD_ASSIGN, tmp.mpoly, tmp.totpoly);
415         }
416
417         /* object had got displacement layer, should copy this layer to save sculpted data */
418         /* NOTE: maybe some other layers should be copied? nazgul */
419         if(CustomData_has_layer(&me->ldata, CD_MDISPS)) {
420                 if (totloop == me->totloop) {
421                         MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS);
422                         CustomData_add_layer(&tmp.ldata, CD_MDISPS, CD_DUPLICATE, mdisps, totloop);
423                 }
424         }
425
426         /* yes, must be before _and_ after tesselate */
427         mesh_update_customdata_pointers(&tmp);
428
429         tmp.totface = mesh_recalcTesselation(&tmp.fdata, &tmp.ldata, &tmp.pdata, tmp.mvert, tmp.totface, tmp.totloop, tmp.totpoly);
430
431         mesh_update_customdata_pointers(&tmp);
432
433
434         CustomData_free(&me->vdata, me->totvert);
435         CustomData_free(&me->edata, me->totedge);
436         CustomData_free(&me->fdata, me->totface);
437         CustomData_free(&me->ldata, me->totloop);
438         CustomData_free(&me->pdata, me->totpoly);
439
440         /*  ok, this should now use new CD shapekey data,
441             which shouuld be fed through the modifier 
442                 stack*/
443         if(tmp.totvert != me->totvert && !did_shapekeys && me->key) {
444                 printf("YEEK! this should be recoded! Shape key loss!!!\n");
445                 if(tmp.key) tmp.key->id.us--;
446                 tmp.key = NULL;
447         }
448
449         *me = tmp;
450 }
451
452 void DM_to_meshkey(DerivedMesh *dm, Mesh *me, KeyBlock *kb)
453 {
454         int a, totvert = dm->getNumVerts(dm);
455         float *fp;
456         MVert *mvert;
457         
458         if(totvert==0 || me->totvert==0 || me->totvert!=totvert) return;
459         
460         if(kb->data) MEM_freeN(kb->data);
461         kb->data= MEM_callocN(me->key->elemsize*me->totvert, "kb->data");
462         kb->totelem= totvert;
463         
464         fp= kb->data;
465         mvert=dm->getVertDataArray(dm, CD_MVERT);
466         
467         for(a=0; a<kb->totelem; a++, fp+=3, mvert++) {
468                 copy_v3_v3(fp, mvert->co);
469         }
470 }
471
472 void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask)
473 {
474         CustomData_set_only_copy(&dm->vertData, mask);
475         CustomData_set_only_copy(&dm->edgeData, mask);
476         CustomData_set_only_copy(&dm->faceData, mask);
477 }
478
479 void DM_add_vert_layer(DerivedMesh *dm, int type, int alloctype, void *layer)
480 {
481         CustomData_add_layer(&dm->vertData, type, alloctype, layer, dm->numVertData);
482 }
483
484 void DM_add_edge_layer(DerivedMesh *dm, int type, int alloctype, void *layer)
485 {
486         CustomData_add_layer(&dm->edgeData, type, alloctype, layer, dm->numEdgeData);
487 }
488
489 void DM_add_tessface_layer(DerivedMesh *dm, int type, int alloctype, void *layer)
490 {
491         CustomData_add_layer(&dm->faceData, type, alloctype, layer, dm->numTessFaceData);
492 }
493
494 void DM_add_loop_layer(DerivedMesh *dm, int type, int alloctype, void *layer)
495 {
496         CustomData_add_layer(&dm->loopData, type, alloctype, layer, dm->numLoopData);
497 }
498
499 void DM_add_poly_layer(DerivedMesh *dm, int type, int alloctype, void *layer)
500 {
501         CustomData_add_layer(&dm->polyData, type, alloctype, layer, dm->numPolyData);
502 }
503
504 void *DM_get_vert_data(DerivedMesh *dm, int index, int type)
505 {
506         return CustomData_get(&dm->vertData, index, type);
507 }
508
509 void *DM_get_edge_data(DerivedMesh *dm, int index, int type)
510 {
511         return CustomData_get(&dm->edgeData, index, type);
512 }
513
514 void *DM_get_tessface_data(DerivedMesh *dm, int index, int type)
515 {
516         return CustomData_get(&dm->faceData, index, type);
517 }
518
519 void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
520 {
521         if(type == CD_MVERT)
522                 return dm->getVertArray(dm);
523
524         return CustomData_get_layer(&dm->vertData, type);
525 }
526
527 void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
528 {
529         if(type == CD_MEDGE)
530                 return dm->getEdgeArray(dm);
531
532         return CustomData_get_layer(&dm->edgeData, type);
533 }
534
535 void *DM_get_tessface_data_layer(DerivedMesh *dm, int type)
536 {
537         if (type == CD_MFACE)
538                 return dm->getTessFaceArray(dm);
539
540         return CustomData_get_layer(&dm->faceData, type);
541 }
542
543 void *DM_get_poly_data_layer(DerivedMesh *dm, int type)
544 {
545         return CustomData_get_layer(&dm->polyData, type);
546 }
547
548 void DM_set_vert_data(DerivedMesh *dm, int index, int type, void *data)
549 {
550         CustomData_set(&dm->vertData, index, type, data);
551 }
552
553 void DM_set_edge_data(DerivedMesh *dm, int index, int type, void *data)
554 {
555         CustomData_set(&dm->edgeData, index, type, data);
556 }
557
558 void DM_set_tessface_data(DerivedMesh *dm, int index, int type, void *data)
559 {
560         CustomData_set(&dm->faceData, index, type, data);
561 }
562
563 void DM_copy_vert_data(DerivedMesh *source, DerivedMesh *dest,
564                                            int source_index, int dest_index, int count)
565 {
566         CustomData_copy_data(&source->vertData, &dest->vertData,
567                                                  source_index, dest_index, count);
568 }
569
570 void DM_copy_edge_data(DerivedMesh *source, DerivedMesh *dest,
571                                            int source_index, int dest_index, int count)
572 {
573         CustomData_copy_data(&source->edgeData, &dest->edgeData,
574                                                  source_index, dest_index, count);
575 }
576
577 void DM_copy_tessface_data(DerivedMesh *source, DerivedMesh *dest,
578                                            int source_index, int dest_index, int count)
579 {
580         CustomData_copy_data(&source->faceData, &dest->faceData,
581                                                  source_index, dest_index, count);
582 }
583
584 void DM_copy_loop_data(DerivedMesh *source, DerivedMesh *dest,
585                        int source_index, int dest_index, int count)
586 {
587         CustomData_copy_data(&source->loopData, &dest->loopData,
588                              source_index, dest_index, count);
589 }
590
591 void DM_copy_poly_data(DerivedMesh *source, DerivedMesh *dest,
592                        int source_index, int dest_index, int count)
593 {
594         CustomData_copy_data(&source->polyData, &dest->polyData,
595                              source_index, dest_index, count);
596 }
597
598 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count)
599 {
600         CustomData_free_elem(&dm->vertData, index, count);
601 }
602
603 void DM_free_edge_data(struct DerivedMesh *dm, int index, int count)
604 {
605         CustomData_free_elem(&dm->edgeData, index, count);
606 }
607
608 void DM_free_tessface_data(struct DerivedMesh *dm, int index, int count)
609 {
610         CustomData_free_elem(&dm->faceData, index, count);
611 }
612
613 void DM_free_loop_data(struct DerivedMesh *dm, int index, int count)
614 {
615         CustomData_free_elem(&dm->loopData, index, count);
616 }
617
618 void DM_free_poly_data(struct DerivedMesh *dm, int index, int count)
619 {
620         CustomData_free_elem(&dm->polyData, index, count);
621 }
622
623 void DM_interp_vert_data(DerivedMesh *source, DerivedMesh *dest,
624                                                  int *src_indices, float *weights,
625                                                  int count, int dest_index)
626 {
627         CustomData_interp(&source->vertData, &dest->vertData, src_indices,
628                                           weights, NULL, count, dest_index);
629 }
630
631 void DM_interp_edge_data(DerivedMesh *source, DerivedMesh *dest,
632                                                  int *src_indices,
633                                                  float *weights, EdgeVertWeight *vert_weights,
634                                                  int count, int dest_index)
635 {
636         CustomData_interp(&source->edgeData, &dest->edgeData, src_indices,
637                                           weights, (float*)vert_weights, count, dest_index);
638 }
639
640 void DM_interp_tessface_data(DerivedMesh *source, DerivedMesh *dest,
641                                                  int *src_indices,
642                                                  float *weights, FaceVertWeight *vert_weights,
643                                                  int count, int dest_index)
644 {
645         CustomData_interp(&source->faceData, &dest->faceData, src_indices,
646                                           weights, (float*)vert_weights, count, dest_index);
647 }
648
649 void DM_swap_tessface_data(DerivedMesh *dm, int index, const int *corner_indices)
650 {
651         CustomData_swap(&dm->faceData, index, corner_indices);
652 }
653
654 void DM_interp_loop_data(DerivedMesh *source, DerivedMesh *dest,
655                          int *src_indices,
656                          float *weights, int count, int dest_index)
657 {
658         CustomData_interp(&source->loopData, &dest->loopData, src_indices,
659                           weights, NULL, count, dest_index);
660 }
661
662 void DM_interp_poly_data(DerivedMesh *source, DerivedMesh *dest,
663                          int *src_indices,
664                          float *weights, int count, int dest_index)
665 {
666         CustomData_interp(&source->polyData, &dest->polyData, src_indices,
667                           weights, NULL, count, dest_index);
668 }
669
670 ///
671 DerivedMesh *mesh_create_derived(Mesh *me, Object *ob, float (*vertCos)[3])
672 {
673         DerivedMesh *dm = CDDM_from_mesh(me, ob);
674         
675         if(!dm)
676                 return NULL;
677         
678         if (vertCos)
679                 CDDM_apply_vert_coords(dm, vertCos);
680
681         CDDM_calc_normals(dm);
682
683         return dm;
684 }
685
686 /***/
687
688 DerivedMesh *mesh_create_derived_for_modifier(Scene *scene, Object *ob, 
689         ModifierData *md, int build_shapekey_layers)
690 {
691         Mesh *me = ob->data;
692         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
693         DerivedMesh *dm;
694
695         md->scene= scene;
696         
697         if (!(md->mode&eModifierMode_Realtime)) return NULL;
698         if (mti->isDisabled && mti->isDisabled(md, 0)) return NULL;
699         
700         if (build_shapekey_layers && me->key && ob->shapenr <= BLI_countlist(&me->key->block)) {
701                 key_to_mesh(BLI_findlink(&me->key->block, ob->shapenr-1), me);
702         }
703         
704         if (mti->type==eModifierTypeType_OnlyDeform) {
705                 int numVerts;
706                 float (*deformedVerts)[3] = mesh_getVertexCos(me, &numVerts);
707
708                 mti->deformVerts(md, ob, NULL, deformedVerts, numVerts, 0, 0);
709                 dm = mesh_create_derived(me, ob, deformedVerts);
710
711                 if (build_shapekey_layers)
712                         add_shapekey_layers(dm, me, ob);
713                 
714                 MEM_freeN(deformedVerts);
715         } else {
716                 DerivedMesh *tdm = mesh_create_derived(me, ob, NULL);
717
718                 if (build_shapekey_layers)
719                         add_shapekey_layers(tdm, me, ob);
720                 
721                 dm = mti->applyModifier(md, ob, tdm, 0, 0);
722
723                 if(tdm != dm) tdm->release(tdm);
724         }
725
726         return dm;
727 }
728
729 static float *get_editbmesh_orco_verts(BMEditMesh *em)
730 {
731         BMIter iter;
732         BMVert *eve;
733         float *orco;
734         int a, totvert;
735
736         /* these may not really be the orco's, but it's only for preview.
737          * could be solver better once, but isn't simple */
738
739         totvert= em->bm->totvert;
740         
741         orco = MEM_mallocN(sizeof(float)*3*totvert, "EditMesh Orco");
742
743         eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
744         for (a=0; eve; eve=BMIter_Step(&iter), a+=3) {
745                 copy_v3_v3(orco+a, eve->co);
746         }
747         
748         return orco;
749 }
750
751 /* orco custom data layer */
752 static void *get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free)
753 {
754         *free= 0;
755
756         if(layer == CD_ORCO) {
757                 /* get original coordinates */
758                 *free= 1;
759
760                 if(em)
761                         return (float(*)[3])get_editbmesh_orco_verts(em);
762                 else
763                         return (float(*)[3])get_mesh_orco_verts(ob);
764         }
765         else if(layer == CD_CLOTH_ORCO) {
766                 /* apply shape key for cloth, this should really be solved
767                    by a more flexible customdata system, but not simple */
768                 if(!em) {
769                         ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
770                         if (clmd) {
771                                 KeyBlock *kb= key_get_keyblock(ob_get_key(ob), clmd->sim_parms->shapekey_rest);
772         
773                                 if(kb->data)
774                                         return kb->data;
775                         }
776                 }
777
778                 return NULL;
779         }
780
781         return NULL;
782 }
783
784 static DerivedMesh *create_orco_dm(Object *ob, Mesh *me, BMEditMesh *em, int layer)
785 {
786         DerivedMesh *dm;
787         float (*orco)[3];
788         int free;
789
790         if(em) dm= CDDM_from_BMEditMesh(em, me, 0);
791         else dm= CDDM_from_mesh(me, ob);
792
793         orco= get_orco_coords_dm(ob, em, layer, &free);
794
795         if(orco) {
796                 CDDM_apply_vert_coords(dm, orco);
797                 if(free) MEM_freeN(orco);
798         }
799
800         CDDM_calc_normals(dm);
801
802         return dm;
803 }
804
805 static void add_orco_dm(Object *ob, BMEditMesh *em, DerivedMesh *dm,
806                                                 DerivedMesh *orcodm, int layer)
807 {
808         float (*orco)[3], (*layerorco)[3];
809         int totvert, free;
810
811         totvert= dm->getNumVerts(dm);
812
813         if(orcodm) {
814                 orco= MEM_callocN(sizeof(float)*3*totvert, "dm orco");
815                 free= 1;
816
817                 if(orcodm->getNumVerts(orcodm) == totvert)
818                         orcodm->getVertCos(orcodm, orco);
819                 else
820                         dm->getVertCos(dm, orco);
821         }
822         else
823                 orco= get_orco_coords_dm(ob, em, layer, &free);
824
825         if(orco) {
826                 if(layer == CD_ORCO)
827                         transform_mesh_orco_verts(ob->data, orco, totvert, 0);
828
829                 if(!(layerorco = DM_get_vert_data_layer(dm, layer))) {
830                         DM_add_vert_layer(dm, layer, CD_CALLOC, NULL);
831                         layerorco = DM_get_vert_data_layer(dm, layer);
832                 }
833
834                 memcpy(layerorco, orco, sizeof(float)*3*totvert);
835                 if(free) MEM_freeN(orco);
836         }
837 }
838
839 /* weight paint colors */
840
841 /* Something of a hack, at the moment deal with weightpaint
842  * by tucking into colors during modifier eval, only in
843  * wpaint mode. Works ok but need to make sure recalc
844  * happens on enter/exit wpaint.
845  */
846
847 void weight_to_rgb(float r_rgb[3], const float weight)
848 {
849         const float blend= ((weight/2.0f)+0.5f);
850
851         if (weight<=0.25f){     // blue->cyan
852                 r_rgb[0]= 0.0f;
853                 r_rgb[1]= blend*weight*4.0f;
854                 r_rgb[2]= blend;
855         }
856         else if (weight<=0.50f){        // cyan->green
857                 r_rgb[0]= 0.0f;
858                 r_rgb[1]= blend;
859                 r_rgb[2]= blend*(1.0f-((weight-0.25f)*4.0f));
860         }
861         else if (weight <= 0.75f){      // green->yellow
862                 r_rgb[0]= blend * ((weight-0.50f)*4.0f);
863                 r_rgb[1]= blend;
864                 r_rgb[2]= 0.0f;
865         }
866         else if (weight <= 1.0f){ // yellow->red
867                 r_rgb[0]= blend;
868                 r_rgb[1]= blend * (1.0f-((weight-0.75f)*4.0f));
869                 r_rgb[2]= 0.0f;
870         }
871 }
872
873 /* draw_flag's for calc_weightpaint_vert_color */
874 enum {
875         CALC_WP_MULTIPAINT= (1<<0),
876         CALC_WP_AUTO_NORMALIZE= (1<<1),
877 };
878
879 static void calc_weightpaint_vert_color(Object *ob, ColorBand *coba, int vert, unsigned char *col, char *dg_flags, int selected, int UNUSED(unselected), const int draw_flag)
880 {
881         Mesh *me = ob->data;
882         float colf[4], input = 0.0f;
883         int i;
884
885         
886         int make_black= FALSE;
887
888         if (me->dvert) {
889                 if ((selected > 1) && (draw_flag & CALC_WP_MULTIPAINT)) {
890                         
891                         int was_a_nonzero= FALSE;
892                         for (i=0; i<me->dvert[vert].totweight; i++) {
893                                 /* in multipaint, get the average if auto normalize is inactive
894                                  * get the sum if it is active */
895                                 if(dg_flags[me->dvert[vert].dw[i].def_nr]) {
896                                         if(me->dvert[vert].dw[i].weight) {
897                                                 input+= me->dvert[vert].dw[i].weight;
898                                                 was_a_nonzero= TRUE;
899                                         }
900                                 }
901                         }
902
903                         /* make it black if the selected groups have no weight on a vertex */
904                         if(was_a_nonzero == FALSE) {
905                                 make_black = TRUE;
906                         }
907                         else if ((draw_flag & CALC_WP_AUTO_NORMALIZE) == FALSE) {
908                                 input /= selected; /* get the average */
909                         }
910                 }
911                 else {
912                         /* default, non tricky behavior */
913                         for (i=0; i<me->dvert[vert].totweight; i++) {
914                                 if (me->dvert[vert].dw[i].def_nr==ob->actdef-1) {
915                                         input+=me->dvert[vert].dw[i].weight;
916                                 }
917                         }
918                 }
919         }
920         
921         if (make_black) {
922                 col[3] = 0;
923                 col[2] = 0;
924                 col[1] = 0;
925                 col[0] = 255;
926                 return;
927         }
928
929         CLAMP(input, 0.0f, 1.0f);       
930
931         if(coba)
932                 do_colorband(coba, input, colf);
933         else
934                 weight_to_rgb(colf, input);
935         
936         col[3] = (unsigned char)(colf[0] * 255.0f);
937         col[2] = (unsigned char)(colf[1] * 255.0f);
938         col[1] = (unsigned char)(colf[2] * 255.0f);
939         col[0] = 255;
940 }
941
942 static ColorBand *stored_cb= NULL;
943
944 void vDM_ColorBand_store(ColorBand *coba)
945 {
946         stored_cb= coba;
947 }
948
949 static void add_weight_mcol_dm(Object *ob, DerivedMesh *dm, int const draw_flag)
950 {
951         // Mesh *me = ob->data; // UNUSED
952         MFace *mf = dm->getTessFaceArray(dm);
953         MLoop *mloop = dm->getLoopArray(dm), *ml;
954         MPoly *mp = dm->getPolyArray(dm);
955         ColorBand *coba= stored_cb;     /* warning, not a local var */
956         unsigned char *wtcol;
957         unsigned char(*wlcol)[4] = NULL;
958         BLI_array_declare(wlcol);
959         int i, j, totface=dm->getNumTessFaces(dm), totloop;
960         int *origIndex = dm->getVertDataArray(dm, CD_ORIGINDEX);
961
962         int defbase_len = BLI_countlist(&ob->defbase);
963         char *defbase_sel = MEM_mallocN(defbase_len * sizeof(char), __func__);
964         int selected = get_selected_defgroups(ob, defbase_sel, defbase_len);
965         int unselected = defbase_len - selected;
966
967         wtcol = MEM_callocN (sizeof (unsigned char) * totface*4*4, "weightmap");
968         
969         /*first add colors to the tesselation faces*/
970         memset(wtcol, 0x55, sizeof (unsigned char) * totface*4*4);
971         for (i=0; i<totface; i++, mf++) {
972                 /*origindex being NULL means we're operating on original mesh data*/
973                 calc_weightpaint_vert_color(ob, coba, mf->v1, &wtcol[(i*4 + 0)*4], defbase_sel, selected, unselected, draw_flag);
974                 calc_weightpaint_vert_color(ob, coba, mf->v2, &wtcol[(i*4 + 1)*4], defbase_sel, selected, unselected, draw_flag);
975                 calc_weightpaint_vert_color(ob, coba, mf->v3, &wtcol[(i*4 + 2)*4], defbase_sel, selected, unselected, draw_flag);
976                 if (mf->v4)
977                         calc_weightpaint_vert_color(ob, coba, mf->v4, &wtcol[(i*4 + 3)*4], defbase_sel, selected, unselected, draw_flag);
978         }
979         
980         CustomData_add_layer(&dm->faceData, CD_WEIGHT_MCOL, CD_ASSIGN, wtcol, totface);
981
982         /*now add to loops, so the data can be passed through the modifier stack*/
983         totloop = 0;
984         for (i=0; i<dm->numPolyData; i++, mp++) {
985                 ml = mloop + mp->loopstart;
986
987                 for (j=0; j<mp->totloop; j++, ml++, totloop++) {
988                         BLI_array_growone(wlcol);
989
990                         calc_weightpaint_vert_color(ob, coba, origIndex ? origIndex[ml->v] : ml->v,
991                                                                                 (unsigned char *)&wlcol[totloop], defbase_sel, selected, unselected, draw_flag);
992                 }
993         }
994
995         MEM_freeN(defbase_sel);
996
997         CustomData_add_layer(&dm->loopData, CD_WEIGHT_MLOOPCOL, CD_ASSIGN, wlcol, totloop);
998 }
999
1000
1001 static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid)
1002 {
1003         KeyBlock *kb;
1004         int i, j, tot;
1005         
1006         if (!me->key)
1007                 return; 
1008         
1009         tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
1010         for (i=0; i<tot; i++) {
1011                 CustomDataLayer *layer = &dm->vertData.layers[CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i)];
1012                 float (*cos)[3], (*kbcos)[3];
1013                 
1014                 for (kb=me->key->block.first; kb; kb=kb->next) {
1015                         if (kb->uid == layer->uid)
1016                                 break;
1017                 }
1018                 
1019                 if (!kb) {
1020                         kb = add_keyblock(me->key, layer->name);
1021                         kb->uid = layer->uid;
1022                 }
1023                 
1024                 if (kb->data)
1025                         MEM_freeN(kb->data);
1026                 
1027                 cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
1028                 kb->totelem = dm->numVertData;
1029
1030                 kb->data = kbcos = MEM_mallocN(sizeof(float)*3*kb->totelem, "kbcos DerivedMesh.c");
1031                 if (kb->uid == actshape_uid) {
1032                         MVert *mvert = dm->getVertArray(dm);
1033                         
1034                         for (j=0; j<dm->numVertData; j++, kbcos++, mvert++) {
1035                                 copy_v3_v3(*kbcos, mvert->co);
1036                         }
1037                 } else {
1038                         for (j=0; j<kb->totelem; j++, cos++, kbcos++) {
1039                                 copy_v3_v3(*kbcos, *cos);
1040                         }
1041                 }
1042         }
1043         
1044         for (kb=me->key->block.first; kb; kb=kb->next) {
1045                 if (kb->totelem != dm->numVertData) {
1046                         if (kb->data)
1047                                 MEM_freeN(kb->data);
1048                         
1049                         kb->totelem = dm->numVertData;
1050                         kb->data = MEM_callocN(sizeof(float)*3*kb->totelem, "kb->data derivedmesh.c");
1051                         fprintf(stderr, "%s: lost a shapekey layer! (bmesh internal error)\n", __func__);
1052                 }
1053         }
1054 }
1055
1056 static void add_shapekey_layers(DerivedMesh *dm, Mesh *me, Object *UNUSED(ob))
1057 {
1058         KeyBlock *kb;
1059         Key *key = me->key;
1060         int a, b;
1061         
1062         if (!me->key)
1063                 return;
1064         
1065         if (dm->numVertData != me->totvert) {
1066                 printf("error in add_shapekey_layers: dm isn't the same size as me\n");
1067                 return;
1068         }
1069                 
1070         for (a=0, kb=key->block.first; kb; kb=kb->next, a++) {
1071                 float (*cos)[3] = CustomData_add_layer_named(&dm->vertData, CD_SHAPEKEY, CD_CALLOC, NULL, dm->numVertData, kb->name);
1072                 int ci = CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, a);
1073                 
1074                 dm->vertData.layers[ci].uid = kb->uid;
1075                 if (kb->totelem != dm->numVertData) {
1076                         printf("error in add_shapekey_layers: totelem and totvert don't match");
1077                         continue;
1078                 }
1079                 
1080                 for (b=0; b<kb->totelem; b++, cos++) {
1081                         copy_v3_v3((float *)cos, ((float*)kb->data)+b*3);
1082                 }
1083         }
1084 }
1085
1086 /* new value for useDeform -1  (hack for the gameengine):
1087  * - apply only the modifier stack of the object, skipping the virtual modifiers,
1088  * - don't apply the key
1089  * - apply deform modifiers and input vertexco
1090  */
1091 static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos)[3],
1092                                                                 DerivedMesh **deform_r, DerivedMesh **final_r,
1093                                                                 int useRenderParams, int useDeform,
1094                                                                 int needMapping, CustomDataMask dataMask, 
1095                                                                 int index, int useCache, int build_shapekey_layers)
1096 {
1097         Mesh *me = ob->data;
1098         ModifierData *firstmd, *md;
1099         LinkNode *datamasks, *curr;
1100         CustomDataMask mask, nextmask, append_mask = 0;
1101         float (*deformedVerts)[3] = NULL;
1102         DerivedMesh *dm=NULL, *orcodm, *clothorcodm, *finaldm;
1103         int numVerts = me->totvert;
1104         int required_mode;
1105         int isPrevDeform= FALSE;
1106         int skipVirtualArmature = (useDeform < 0);
1107         MultiresModifierData *mmd= get_multires_modifier(scene, ob, 0);
1108         int has_multires = mmd != NULL, multires_applied = 0;
1109         int sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt;
1110
1111         int draw_flag= ((scene->toolsettings->multipaint ? CALC_WP_MULTIPAINT : 0) |
1112                         (scene->toolsettings->auto_normalize ? CALC_WP_AUTO_NORMALIZE : 0));
1113
1114         if(mmd && !mmd->sculptlvl)
1115                 has_multires = 0;
1116
1117         if(!skipVirtualArmature) {
1118                 firstmd = modifiers_getVirtualModifierList(ob);
1119         }
1120         else {
1121                 /* game engine exception */
1122                 firstmd = ob->modifiers.first;
1123                 if(firstmd && firstmd->type == eModifierType_Armature)
1124                         firstmd = firstmd->next;
1125         }
1126
1127         md = firstmd;
1128
1129         modifiers_clearErrors(ob);
1130
1131         if(useRenderParams) required_mode = eModifierMode_Render;
1132         else required_mode = eModifierMode_Realtime;
1133
1134         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode);
1135         curr = datamasks;
1136
1137         if(deform_r) *deform_r = NULL;
1138         *final_r = NULL;
1139
1140         if(useDeform) {
1141                 if(inputVertexCos)
1142                         deformedVerts = inputVertexCos;
1143                 
1144                 /* Apply all leading deforming modifiers */
1145                 for(;md; md = md->next, curr = curr->next) {
1146                         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1147
1148                         md->scene= scene;
1149                         
1150                         if(!modifier_isEnabled(scene, md, required_mode)) continue;
1151                         if(useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) continue;
1152
1153                         if(mti->type == eModifierTypeType_OnlyDeform) {
1154                                 if(!deformedVerts)
1155                                         deformedVerts = mesh_getVertexCos(me, &numVerts);
1156
1157                                 mti->deformVerts(md, ob, NULL, deformedVerts, numVerts, useRenderParams, useDeform);
1158                         } else {
1159                                 break;
1160                         }
1161                         
1162                         /* grab modifiers until index i */
1163                         if((index >= 0) && (modifiers_indexInObject(ob, md) >= index))
1164                                 break;
1165                 }
1166
1167                 /* Result of all leading deforming modifiers is cached for
1168                  * places that wish to use the original mesh but with deformed
1169                  * coordinates (vpaint, etc.)
1170                  */
1171                 if (deform_r) {
1172                         *deform_r = CDDM_from_mesh(me, ob);
1173                         
1174                         if (build_shapekey_layers)
1175                                 add_shapekey_layers(dm, me, ob);
1176                         
1177                         if(deformedVerts) {
1178                                 CDDM_apply_vert_coords(*deform_r, deformedVerts);
1179                                 CDDM_calc_normals(*deform_r);
1180                         }
1181                 }
1182         } else {
1183                 /* default behaviour for meshes */
1184                 if(inputVertexCos)
1185                         deformedVerts = inputVertexCos;
1186                 else
1187                         deformedVerts = mesh_getVertexCos(me, &numVerts);
1188         }
1189
1190
1191         /* Now apply all remaining modifiers. If useDeform is off then skip
1192          * OnlyDeform ones. 
1193          */
1194         dm = NULL;
1195         orcodm = NULL;
1196         clothorcodm = NULL;
1197
1198         for(;md; md = md->next, curr = curr->next) {
1199                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1200
1201                 md->scene= scene;
1202
1203                 if(!modifier_isEnabled(scene, md, required_mode)) continue;
1204                 if(mti->type == eModifierTypeType_OnlyDeform && !useDeform) continue;
1205                 if((mti->flags & eModifierTypeFlag_RequiresOriginalData) && dm) {
1206                         modifier_setError(md, "Modifier requires original data, bad stack position.");
1207                         continue;
1208                 }
1209                 if(sculpt_mode && (!has_multires || multires_applied)) {
1210                         int unsupported= 0;
1211
1212                         if(scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM)
1213                                 unsupported|= mti->type != eModifierTypeType_OnlyDeform;
1214
1215                         unsupported|= md->type == eModifierType_Multires && ((MultiresModifierData*)md)->sculptlvl==0;
1216                         unsupported|= multires_applied;
1217
1218                         if(unsupported) {
1219                                 modifier_setError(md, "Not supported in sculpt mode.");
1220                                 continue;
1221                         }
1222                 }
1223                 if(needMapping && !modifier_supportsMapping(md)) continue;
1224                 if(useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) continue;
1225
1226                 /* add an orco layer if needed by this modifier */
1227                 if(mti->requiredDataMask)
1228                         mask = mti->requiredDataMask(ob, md);
1229                 else
1230                         mask = 0;
1231
1232                 if(dm && (mask & CD_MASK_ORCO))
1233                         add_orco_dm(ob, NULL, dm, orcodm, CD_ORCO);
1234
1235                 /* How to apply modifier depends on (a) what we already have as
1236                  * a result of previous modifiers (could be a DerivedMesh or just
1237                  * deformed vertices) and (b) what type the modifier is.
1238                  */
1239
1240                 if(mti->type == eModifierTypeType_OnlyDeform) {
1241                         /* No existing verts to deform, need to build them. */
1242                         if(!deformedVerts) {
1243                                 if(dm) {
1244                                         /* Deforming a derived mesh, read the vertex locations
1245                                          * out of the mesh and deform them. Once done with this
1246                                          * run of deformers verts will be written back.
1247                                          */
1248                                         numVerts = dm->getNumVerts(dm);
1249                                         deformedVerts =
1250                                                 MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
1251                                         dm->getVertCos(dm, deformedVerts);
1252                                 } else {
1253                                         deformedVerts = mesh_getVertexCos(me, &numVerts);
1254                                 }
1255                         }
1256
1257                         /* if this is not the last modifier in the stack then recalculate the normals
1258                          * to avoid giving bogus normals to the next modifier see: [#23673] */
1259                         if(dm && isPrevDeform &&  mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1260                                 /* XXX, this covers bug #23673, but we may need normal calc for other types */
1261                                 if(dm && dm->type == DM_TYPE_CDDM) {
1262                                         CDDM_apply_vert_coords(dm, deformedVerts);
1263                                         CDDM_calc_normals(dm);
1264                                 }
1265                         }
1266
1267                         mti->deformVerts(md, ob, dm, deformedVerts, numVerts, useRenderParams, useDeform);
1268                 } else {
1269                         DerivedMesh *ndm;
1270
1271                         /* determine which data layers are needed by following modifiers */
1272                         if(curr->next)
1273                                 nextmask= (CustomDataMask)GET_INT_FROM_POINTER(curr->next->link);
1274                         else
1275                                 nextmask= dataMask;
1276
1277                         /* apply vertex coordinates or build a DerivedMesh as necessary */
1278                         if(dm) {
1279                                 if(deformedVerts) {
1280                                         DerivedMesh *tdm = CDDM_copy(dm, 0);
1281                                         dm->release(dm);
1282                                         dm = tdm;
1283
1284                                         CDDM_apply_vert_coords(dm, deformedVerts);
1285                                         CDDM_calc_normals(dm);
1286                                 }
1287                         } else {
1288                                 dm = CDDM_from_mesh(me, ob);
1289
1290                                 if (build_shapekey_layers)
1291                                         add_shapekey_layers(dm, me, ob);
1292
1293                                 if(deformedVerts) {
1294                                         CDDM_apply_vert_coords(dm, deformedVerts);
1295                                         CDDM_calc_normals(dm);
1296                                 }
1297
1298                                 /* Constructive modifiers need to have an origindex
1299                                  * otherwise they wont have anywhere to copy the data from.
1300                                  *
1301                                  * Also create ORIGINDEX data if any of the following modifiers
1302                                  * requests it, this way Mirror, Solidify etc will keep ORIGINDEX
1303                                  * data by using generic DM_copy_vert_data() functions.
1304                                  */
1305                                 if(needMapping || (nextmask & CD_MASK_ORIGINDEX)) {
1306                                         /* calc */
1307                                         DM_add_vert_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
1308                                         DM_add_edge_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
1309                                         DM_add_poly_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
1310
1311                                         range_vn_i(DM_get_vert_data_layer(dm, CD_ORIGINDEX), dm->numVertData, 0);
1312                                         range_vn_i(DM_get_edge_data_layer(dm, CD_ORIGINDEX), dm->numEdgeData, 0);
1313                                         range_vn_i(DM_get_poly_data_layer(dm, CD_ORIGINDEX), dm->numPolyData, 0);
1314                                 }
1315
1316                                 if((dataMask & CD_MASK_WEIGHT_MCOL) && (ob->mode & OB_MODE_WEIGHT_PAINT))
1317                                         add_weight_mcol_dm(ob, dm, draw_flag);
1318
1319                         }
1320
1321                         
1322                         /* set the DerivedMesh to only copy needed data */
1323                         mask= (CustomDataMask)GET_INT_FROM_POINTER(curr->link);
1324                         /* needMapping check here fixes bug [#28112], otherwise its
1325                          * possible that it wont be copied */
1326                         mask |= append_mask;
1327                         DM_set_only_copy(dm, mask | (needMapping ? CD_MASK_ORIGINDEX : 0));
1328                         
1329                         /* add cloth rest shape key if need */
1330                         if(mask & CD_MASK_CLOTH_ORCO)
1331                                 add_orco_dm(ob, NULL, dm, clothorcodm, CD_CLOTH_ORCO);
1332
1333                         /* add an origspace layer if needed */
1334                         if(((CustomDataMask)GET_INT_FROM_POINTER(curr->link)) & CD_MASK_ORIGSPACE)
1335                                 if(!CustomData_has_layer(&dm->faceData, CD_ORIGSPACE))
1336                                         DM_add_tessface_layer(dm, CD_ORIGSPACE, CD_DEFAULT, NULL);
1337
1338                         ndm = mti->applyModifier(md, ob, dm, useRenderParams, useCache);
1339
1340                         if(ndm) {
1341                                 /* if the modifier returned a new dm, release the old one */
1342                                 if(dm && dm != ndm) dm->release(dm);
1343
1344                                 dm = ndm;
1345
1346                                 if(deformedVerts) {
1347                                         if(deformedVerts != inputVertexCos)
1348                                                 MEM_freeN(deformedVerts);
1349
1350                                         deformedVerts = NULL;
1351                                 }
1352                         } 
1353
1354                         /* create an orco derivedmesh in parallel */
1355                         if(nextmask & CD_MASK_ORCO) {
1356                                 if(!orcodm)
1357                                         orcodm= create_orco_dm(ob, me, NULL, CD_ORCO);
1358
1359                                 nextmask &= ~CD_MASK_ORCO;
1360                                 DM_set_only_copy(orcodm, nextmask | CD_MASK_ORIGINDEX);
1361                                 ndm = mti->applyModifier(md, ob, orcodm, useRenderParams, 0);
1362
1363                                 if(ndm) {
1364                                         /* if the modifier returned a new dm, release the old one */
1365                                         if(orcodm && orcodm != ndm) orcodm->release(orcodm);
1366                                         orcodm = ndm;
1367                                 }
1368                         }
1369
1370                         /* create cloth orco derivedmesh in parallel */
1371                         if(nextmask & CD_MASK_CLOTH_ORCO) {
1372                                 if(!clothorcodm)
1373                                         clothorcodm= create_orco_dm(ob, me, NULL, CD_CLOTH_ORCO);
1374
1375                                 nextmask &= ~CD_MASK_CLOTH_ORCO;
1376                                 DM_set_only_copy(clothorcodm, nextmask | CD_MASK_ORIGINDEX);
1377                                 ndm = mti->applyModifier(md, ob, clothorcodm, useRenderParams, 0);
1378
1379                                 if(ndm) {
1380                                         /* if the modifier returned a new dm, release the old one */
1381                                         if(clothorcodm && clothorcodm != ndm) clothorcodm->release(clothorcodm);
1382                                         clothorcodm = ndm;
1383                                 }
1384                         }
1385
1386                         /* in case of dynamic paint, make sure preview mask remains for following modifiers */
1387                         if (md->type == eModifierType_DynamicPaint)
1388                                 append_mask |= CD_MASK_WEIGHT_MCOL;
1389                 }
1390
1391                 isPrevDeform= (mti->type == eModifierTypeType_OnlyDeform);
1392
1393                 /* grab modifiers until index i */
1394                 if((index >= 0) && (modifiers_indexInObject(ob, md) >= index))
1395                         break;
1396
1397                 if(sculpt_mode && md->type == eModifierType_Multires)
1398                         multires_applied = 1;
1399         }
1400
1401         for(md=firstmd; md; md=md->next)
1402                 modifier_freeTemporaryData(md);
1403
1404         /* Yay, we are done. If we have a DerivedMesh and deformed vertices
1405          * need to apply these back onto the DerivedMesh. If we have no
1406          * DerivedMesh then we need to build one.
1407          */
1408         if(dm && deformedVerts) {
1409                 finaldm = CDDM_copy(dm, 0);
1410
1411                 dm->release(dm);
1412
1413                 CDDM_apply_vert_coords(finaldm, deformedVerts);
1414                 CDDM_calc_normals(finaldm);
1415
1416                 if((dataMask & CD_MASK_WEIGHT_MCOL) && (ob->mode & OB_MODE_WEIGHT_PAINT))
1417                         add_weight_mcol_dm(ob, finaldm, draw_flag);
1418         } else if(dm) {
1419                 finaldm = dm;
1420         } else {
1421                 int recalc_normals= 0;
1422
1423                 finaldm = CDDM_from_mesh(me, ob);
1424                 
1425                 if(build_shapekey_layers) {
1426                         add_shapekey_layers(finaldm, me, ob);
1427                         recalc_normals= 1;
1428                 }
1429                 
1430                 if(deformedVerts) {
1431                         CDDM_apply_vert_coords(finaldm, deformedVerts);
1432                         recalc_normals= 1;
1433                 }
1434
1435                 if(recalc_normals)
1436                         CDDM_calc_normals(finaldm);
1437                 
1438                 if((dataMask & CD_MASK_WEIGHT_MCOL) && (ob->mode & OB_MODE_WEIGHT_PAINT))
1439                         add_weight_mcol_dm(ob, finaldm, draw_flag);
1440         }
1441
1442         /* add an orco layer if needed */
1443         if(dataMask & CD_MASK_ORCO) {
1444                 add_orco_dm(ob, NULL, finaldm, orcodm, CD_ORCO);
1445
1446                 if(deform_r && *deform_r)
1447                         add_orco_dm(ob, NULL, *deform_r, NULL, CD_ORCO);
1448         }
1449
1450 #ifdef WITH_GAMEENGINE
1451         /* NavMesh - this is a hack but saves having a NavMesh modifier */
1452         if ((ob->gameflag & OB_NAVMESH) && (finaldm->type == DM_TYPE_CDDM)) {
1453                 DerivedMesh *tdm;
1454                 tdm= navmesh_dm_createNavMeshForVisualization(finaldm);
1455                 if (finaldm != tdm) {
1456                         finaldm->release(finaldm);
1457                         finaldm= tdm;
1458                 }
1459         }
1460 #endif /* WITH_GAMEENGINE */
1461
1462         /* Re-tesselation is necessary to push render data (uvs, textures, colors)
1463            from loops and polys onto the tessfaces. This may be currently be redundant
1464            in cases where the render mode doesn't use these inputs, but ideally
1465            eventually tesselation would happen on-demand, and this is one of the primary
1466            places it would be needed. */
1467         finaldm->recalcTesselation(finaldm);
1468         finaldm->calcNormals(finaldm);
1469
1470         *final_r = finaldm;
1471
1472         if(orcodm)
1473                 orcodm->release(orcodm);
1474         if(clothorcodm)
1475                 clothorcodm->release(clothorcodm);
1476
1477         if(deformedVerts && deformedVerts != inputVertexCos)
1478                 MEM_freeN(deformedVerts);
1479
1480         BLI_linklist_free(datamasks, NULL);
1481 }
1482
1483 float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *numVerts_r))[3]
1484 {
1485         int i, numVerts = *numVerts_r = em->bm->totvert;
1486         float (*cos)[3];
1487         BMIter iter;
1488         BMVert *eve;
1489
1490         cos = MEM_mallocN(sizeof(float)*3*numVerts, "vertexcos");
1491
1492         eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
1493         for (i=0; eve; eve=BMIter_Step(&iter), i++) {
1494                 copy_v3_v3(cos[i], eve->co);
1495         }
1496
1497         return cos;
1498 }
1499
1500 int editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *dm)
1501 {
1502         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1503         int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1504
1505         if(!modifier_isEnabled(scene, md, required_mode)) return 0;
1506         if((mti->flags & eModifierTypeFlag_RequiresOriginalData) && dm) {
1507                 modifier_setError(md, "Modifier requires original data, bad stack position.");
1508                 return 0;
1509         }
1510         
1511         return 1;
1512 }
1513
1514 static void editbmesh_calc_modifiers(Scene *scene, Object *ob, BMEditMesh *em, DerivedMesh **cage_r,
1515                                                                         DerivedMesh **final_r,
1516                                                                         CustomDataMask dataMask)
1517 {
1518         ModifierData *md;
1519         float (*deformedVerts)[3] = NULL;
1520         CustomDataMask mask;
1521         DerivedMesh *dm = NULL, *orcodm = NULL, *finaldm = NULL;
1522         int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
1523         LinkNode *datamasks, *curr;
1524         int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
1525
1526         modifiers_clearErrors(ob);
1527
1528         if(cage_r && cageIndex == -1) {
1529                 *cage_r = getEditDerivedBMesh(em, ob, NULL);
1530         }
1531
1532         md = modifiers_getVirtualModifierList(ob);
1533
1534         datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode);
1535
1536         curr = datamasks;
1537         for(i = 0; md; i++, md = md->next, curr = curr->next) {
1538                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1539
1540                 md->scene= scene;
1541                 
1542                 if(!editbmesh_modifier_is_enabled(scene, md, dm))
1543                         continue;
1544
1545                 /* add an orco layer if needed by this modifier */
1546                 if(dm && mti->requiredDataMask) {
1547                         mask = mti->requiredDataMask(ob, md);
1548                         if(mask & CD_MASK_ORCO)
1549                                 add_orco_dm(ob, em, dm, orcodm, CD_ORCO);
1550                 }
1551
1552                 /* How to apply modifier depends on (a) what we already have as
1553                  * a result of previous modifiers (could be a DerivedMesh or just
1554                  * deformed vertices) and (b) what type the modifier is.
1555                  */
1556
1557                 if(mti->type == eModifierTypeType_OnlyDeform) {
1558                         /* No existing verts to deform, need to build them. */
1559                         if(!deformedVerts) {
1560                                 if(dm) {
1561                                         /* Deforming a derived mesh, read the vertex locations
1562                                          * out of the mesh and deform them. Once done with this
1563                                          * run of deformers verts will be written back.
1564                                          */
1565                                         numVerts = dm->getNumVerts(dm);
1566                                         deformedVerts =
1567                                                 MEM_mallocN(sizeof(*deformedVerts) * numVerts, "dfmv");
1568                                         dm->getVertCos(dm, deformedVerts);
1569                                 } else {
1570                                         deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
1571                                 }
1572                         }
1573
1574                         if (mti->deformVertsEM)
1575                                 mti->deformVertsEM(md, ob, em, dm, deformedVerts, numVerts);
1576                         else mti->deformVerts(md, ob, dm, deformedVerts, numVerts, 0, 0);
1577                 } else {
1578                         DerivedMesh *ndm;
1579
1580                         /* apply vertex coordinates or build a DerivedMesh as necessary */
1581                         if(dm) {
1582                                 if(deformedVerts) {
1583                                         DerivedMesh *tdm = CDDM_copy(dm, 0);
1584                                         if(!(cage_r && dm == *cage_r)) dm->release(dm);
1585                                         dm = tdm;
1586
1587                                         CDDM_apply_vert_coords(dm, deformedVerts);
1588                                         CDDM_calc_normals(dm);
1589                                 } else if(cage_r && dm == *cage_r) {
1590                                         /* dm may be changed by this modifier, so we need to copy it
1591                                          */
1592                                         dm = CDDM_copy(dm, 0);
1593                                 }
1594
1595                         } else {
1596                                 dm = CDDM_from_BMEditMesh(em, ob->data, 0);
1597
1598                                 if(deformedVerts) {
1599                                         CDDM_apply_vert_coords(dm, deformedVerts);
1600                                         CDDM_calc_normals(dm);
1601                                 }
1602                         }
1603
1604                         /* create an orco derivedmesh in parallel */
1605                         mask= (CustomDataMask)GET_INT_FROM_POINTER(curr->link);
1606                         if(mask & CD_MASK_ORCO) {
1607                                 if(!orcodm)
1608                                         orcodm= create_orco_dm(ob, ob->data, em, CD_ORCO);
1609
1610                                 mask &= ~CD_MASK_ORCO;
1611                                 DM_set_only_copy(orcodm, mask | CD_MASK_ORIGINDEX);
1612
1613                                 if (mti->applyModifierEM)
1614                                         ndm = mti->applyModifierEM(md, ob, em, orcodm);
1615                                 else
1616                                         ndm = mti->applyModifier(md, ob, orcodm, 0, 0);
1617
1618                                 if(ndm) {
1619                                         /* if the modifier returned a new dm, release the old one */
1620                                         if(orcodm && orcodm != ndm) orcodm->release(orcodm);
1621                                         orcodm = ndm;
1622                                 }
1623                         }
1624
1625                         /* set the DerivedMesh to only copy needed data */
1626                         mask= (CustomDataMask)GET_INT_FROM_POINTER(curr->link); /* CD_MASK_ORCO may have been cleared above */
1627
1628                         DM_set_only_copy(dm, mask | CD_MASK_ORIGINDEX);
1629
1630                         if(mask & CD_MASK_ORIGSPACE)
1631                                 if(!CustomData_has_layer(&dm->faceData, CD_ORIGSPACE))
1632                                         DM_add_tessface_layer(dm, CD_ORIGSPACE, CD_DEFAULT, NULL);
1633                         
1634                         if (mti->applyModifierEM)
1635                                 ndm = mti->applyModifierEM(md, ob, em, dm);
1636                         else
1637                                 ndm = mti->applyModifier(md, ob, dm, 0, 0);
1638
1639                         if (ndm) {
1640                                 if(dm && dm != ndm)
1641                                         dm->release(dm);
1642
1643                                 dm = ndm;
1644
1645                                 if (deformedVerts) {
1646                                         MEM_freeN(deformedVerts);
1647                                         deformedVerts = NULL;
1648                                 }
1649                         }
1650                 }
1651
1652                 if(cage_r && i == cageIndex) {
1653                         if(dm && deformedVerts) {
1654                                 *cage_r = CDDM_copy(dm, 0);
1655                                 CDDM_apply_vert_coords(*cage_r, deformedVerts);
1656                         } else if(dm) {
1657                                 *cage_r = dm;
1658                         } else {
1659                                 *cage_r =
1660                                         getEditDerivedBMesh(em, ob,
1661                                                 deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
1662                         }
1663                 }
1664         }
1665
1666         BLI_linklist_free(datamasks, NULL);
1667
1668         /* Yay, we are done. If we have a DerivedMesh and deformed vertices need
1669          * to apply these back onto the DerivedMesh. If we have no DerivedMesh
1670          * then we need to build one.
1671          */
1672         if(dm && deformedVerts) {
1673                 finaldm = CDDM_copy(dm, 0);
1674
1675                 if(!(cage_r && dm == *cage_r)) dm->release(dm);
1676
1677                 CDDM_apply_vert_coords(*final_r, deformedVerts);
1678         } else if (dm) {
1679                 finaldm = dm;
1680         } else if (!deformedVerts && cage_r && *cage_r) {
1681                 finaldm = *cage_r;
1682         } else {
1683                 finaldm = getEditDerivedBMesh(em, ob, deformedVerts);
1684                 deformedVerts = NULL;
1685         }
1686
1687         finaldm->calcNormals(finaldm);
1688
1689         *final_r = finaldm;
1690
1691         /* add an orco layer if needed */
1692         if(dataMask & CD_MASK_ORCO)
1693                 add_orco_dm(ob, em, *final_r, orcodm, CD_ORCO);
1694
1695         if(orcodm)
1696                 orcodm->release(orcodm);
1697
1698         if(deformedVerts)
1699                 MEM_freeN(deformedVerts);
1700 }
1701
1702 static void clear_mesh_caches(Object *ob)
1703 {
1704         Mesh *me= ob->data;
1705
1706                 /* also serves as signal to remake texspace */
1707         if (ob->bb) {
1708                 MEM_freeN(ob->bb);
1709                 ob->bb = NULL;
1710         }
1711         if (me->bb) {
1712                 MEM_freeN(me->bb);
1713                 me->bb = NULL;
1714         }
1715
1716         freedisplist(&ob->disp);
1717
1718         if (ob->derivedFinal) {
1719                 ob->derivedFinal->needsFree = 1;
1720                 ob->derivedFinal->release(ob->derivedFinal);
1721                 ob->derivedFinal= NULL;
1722         }
1723         if (ob->derivedDeform) {
1724                 ob->derivedDeform->needsFree = 1;
1725                 ob->derivedDeform->release(ob->derivedDeform);
1726                 ob->derivedDeform= NULL;
1727         }
1728
1729         if(ob->sculpt) {
1730                 object_sculpt_modifiers_changed(ob);
1731         }
1732 }
1733
1734 static void mesh_build_data(Scene *scene, Object *ob, CustomDataMask dataMask,
1735         int build_shapekey_layers)
1736 {
1737         Object *obact = scene->basact?scene->basact->object:NULL;
1738         int editing = paint_facesel_test(ob);
1739         /* weight paint and face select need original indices because of selection buffer drawing */
1740         int needMapping = (ob==obact) && (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT|OB_MODE_VERTEX_PAINT|OB_MODE_TEXTURE_PAINT)));
1741
1742         clear_mesh_caches(ob);
1743
1744         mesh_calc_modifiers(scene, ob, NULL, &ob->derivedDeform,
1745                                                 &ob->derivedFinal, 0, 1,
1746                                                 needMapping, dataMask, -1, 1, build_shapekey_layers);
1747
1748         DM_set_object_boundbox (ob, ob->derivedFinal);
1749
1750         ob->derivedFinal->needsFree = 0;
1751         ob->derivedDeform->needsFree = 0;
1752         ob->lastDataMask = dataMask;
1753 }
1754
1755 static void editbmesh_build_data(Scene *scene, Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
1756 {
1757         clear_mesh_caches(obedit);
1758
1759         if (em->derivedFinal) {
1760                 if (em->derivedFinal!=em->derivedCage) {
1761                         em->derivedFinal->needsFree = 1;
1762                         em->derivedFinal->release(em->derivedFinal);
1763                 }
1764                 em->derivedFinal = NULL;
1765         }
1766         if (em->derivedCage) {
1767                 em->derivedCage->needsFree = 1;
1768                 em->derivedCage->release(em->derivedCage);
1769                 em->derivedCage = NULL;
1770         }
1771
1772         editbmesh_calc_modifiers(scene, obedit, em, &em->derivedCage, &em->derivedFinal, dataMask);
1773         DM_set_object_boundbox (obedit, em->derivedFinal);
1774
1775         em->lastDataMask = dataMask;
1776         em->derivedFinal->needsFree = 0;
1777         em->derivedCage->needsFree = 0;
1778 }
1779
1780 void makeDerivedMesh(Scene *scene, Object *ob, BMEditMesh *em,
1781         CustomDataMask dataMask, int build_shapekey_layers)
1782 {
1783         if (em) {
1784                 editbmesh_build_data(scene, ob, em, dataMask);
1785         } else {
1786                 mesh_build_data(scene, ob, dataMask, build_shapekey_layers);
1787         }
1788 }
1789
1790 /***/
1791
1792 DerivedMesh *mesh_get_derived_final(Scene *scene, Object *ob, CustomDataMask dataMask)
1793 {
1794         /* if there's no derived mesh or the last data mask used doesn't include
1795          * the data we need, rebuild the derived mesh
1796          */
1797         if(!ob->derivedFinal || (dataMask & ob->lastDataMask) != dataMask)
1798                 mesh_build_data(scene, ob, dataMask, 0);
1799
1800         return ob->derivedFinal;
1801 }
1802
1803 DerivedMesh *mesh_get_derived_deform(Scene *scene, Object *ob, CustomDataMask dataMask)
1804 {
1805         /* if there's no derived mesh or the last data mask used doesn't include
1806          * the data we need, rebuild the derived mesh
1807          */
1808         if(!ob->derivedDeform || (dataMask & ob->lastDataMask) != dataMask)
1809                 mesh_build_data(scene, ob, dataMask, 0);
1810
1811         return ob->derivedDeform;
1812 }
1813
1814 DerivedMesh *mesh_create_derived_render(Scene *scene, Object *ob, CustomDataMask dataMask)
1815 {
1816         DerivedMesh *final;
1817         
1818         mesh_calc_modifiers(scene, ob, NULL, NULL, &final, 1, 1, 0, dataMask, -1, 0, 0);
1819
1820         return final;
1821 }
1822
1823 DerivedMesh *mesh_create_derived_index_render(Scene *scene, Object *ob, CustomDataMask dataMask, int index)
1824 {
1825         DerivedMesh *final;
1826         
1827         mesh_calc_modifiers(scene, ob, NULL, NULL, &final, 1, 1, 0, dataMask, index, 0, 0);
1828
1829         return final;
1830 }
1831
1832 DerivedMesh *mesh_create_derived_view(Scene *scene, Object *ob, CustomDataMask dataMask)
1833 {
1834         DerivedMesh *final;
1835
1836         mesh_calc_modifiers(scene, ob, NULL, NULL, &final, 0, 1, 0, dataMask, -1, 0, 0);
1837
1838         return final;
1839 }
1840
1841 DerivedMesh *mesh_create_derived_no_deform(Scene *scene, Object *ob, float (*vertCos)[3],
1842                                                                                    CustomDataMask dataMask)
1843 {
1844         DerivedMesh *final;
1845         
1846         mesh_calc_modifiers(scene, ob, vertCos, NULL, &final, 0, 0, 0, dataMask, -1, 0, 0);
1847
1848         return final;
1849 }
1850
1851 DerivedMesh *mesh_create_derived_no_virtual(Scene *scene, Object *ob, float (*vertCos)[3],
1852                                                                                         CustomDataMask dataMask)
1853 {
1854         DerivedMesh *final;
1855         
1856         mesh_calc_modifiers(scene, ob, vertCos, NULL, &final, 0, -1, 0, dataMask, -1, 0, 0);
1857
1858         return final;
1859 }
1860
1861 DerivedMesh *mesh_create_derived_physics(Scene *scene, Object *ob, float (*vertCos)[3],
1862                                                                                         CustomDataMask dataMask)
1863 {
1864         DerivedMesh *final;
1865         
1866         mesh_calc_modifiers(scene, ob, vertCos, NULL, &final, 0, -1, 1, dataMask, -1, 0, 0);
1867
1868         return final;
1869 }
1870
1871 DerivedMesh *mesh_create_derived_no_deform_render(Scene *scene, Object *ob,
1872                                                                                                   float (*vertCos)[3],
1873                                                                                                   CustomDataMask dataMask)
1874 {
1875         DerivedMesh *final;
1876
1877         mesh_calc_modifiers(scene, ob, vertCos, NULL, &final, 1, 0, 0, dataMask, -1, 0, 0);
1878
1879         return final;
1880 }
1881
1882 /***/
1883
1884 DerivedMesh *editbmesh_get_derived_cage_and_final(Scene *scene, Object *obedit, BMEditMesh *em, DerivedMesh **final_r,
1885                                                                                                  CustomDataMask dataMask)
1886 {
1887         /* if there's no derived mesh or the last data mask used doesn't include
1888          * the data we need, rebuild the derived mesh
1889          */
1890         if(!em->derivedCage ||
1891            (em->lastDataMask & dataMask) != dataMask)
1892                 editbmesh_build_data(scene, obedit, em, dataMask);
1893
1894         *final_r = em->derivedFinal;
1895         return em->derivedCage;
1896 }
1897
1898 DerivedMesh *editbmesh_get_derived_cage(Scene *scene, Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
1899 {
1900         /* if there's no derived mesh or the last data mask used doesn't include
1901          * the data we need, rebuild the derived mesh
1902          */
1903         if(!em->derivedCage ||
1904            (em->lastDataMask & dataMask) != dataMask)
1905                 editbmesh_build_data(scene, obedit, em, dataMask);
1906
1907         return em->derivedCage;
1908 }
1909
1910 DerivedMesh *editbmesh_get_derived_base(Object *obedit, BMEditMesh *em)
1911 {
1912         return getEditDerivedBMesh(em, obedit, NULL);
1913 }
1914
1915
1916 /* ********* For those who don't grasp derived stuff! (ton) :) *************** */
1917
1918 static void make_vertexcosnos__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s)
1919 {
1920         float *vec = userData;
1921         
1922         vec+= 6*index;
1923
1924         /* check if we've been here before (normal should not be 0) */
1925         if(vec[3] || vec[4] || vec[5]) return;
1926
1927         copy_v3_v3(vec, co);
1928         vec+= 3;
1929         if(no_f) {
1930                 copy_v3_v3(vec, no_f);
1931         }
1932         else {
1933                 normal_short_to_float_v3(vec, no_s);
1934         }
1935 }
1936
1937 /* always returns original amount me->totvert of vertices and normals, but fully deformed and subsurfered */
1938 /* this is needed for all code using vertexgroups (no subsurf support) */
1939 /* it stores the normals as floats, but they can still be scaled as shorts (32767 = unit) */
1940 /* in use now by vertex/weight paint and particle generating */
1941
1942 float *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
1943 {
1944         Mesh *me= ob->data;
1945         DerivedMesh *dm;
1946         float *vertexcosnos;
1947         
1948         /* lets prevent crashing... */
1949         if(ob->type!=OB_MESH || me->totvert==0)
1950                 return NULL;
1951         
1952         dm= mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH|CD_MASK_ORIGINDEX);
1953         vertexcosnos= MEM_callocN(6*sizeof(float)*me->totvert, "vertexcosnos map");
1954         
1955         if(dm->foreachMappedVert) {
1956                 dm->foreachMappedVert(dm, make_vertexcosnos__mapFunc, vertexcosnos);
1957         }
1958         else {
1959                 float *fp= vertexcosnos;
1960                 int a;
1961                 
1962                 for(a=0; a< me->totvert; a++, fp+=6) {
1963                         dm->getVertCo(dm, a, fp);
1964                         dm->getVertNo(dm, a, fp+3);
1965                 }
1966         }
1967         
1968         dm->release(dm);
1969         return vertexcosnos;
1970 }
1971
1972 /* ******************* GLSL ******************** */
1973
1974 typedef struct
1975 {
1976         float * precomputedFaceNormals;
1977         MTFace * mtface;        // texture coordinates
1978         MFace * mface;          // indices
1979         MVert * mvert;          // vertices & normals
1980         float (*orco)[3];
1981         float (*tangent)[4];    // destination
1982         int numTessFaces;
1983
1984 } SGLSLMeshToTangent;
1985
1986 // interface
1987 #include "mikktspace.h"
1988
1989 static int GetNumFaces(const SMikkTSpaceContext * pContext)
1990 {
1991         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
1992         return pMesh->numTessFaces;
1993 }
1994
1995 static int GetNumVertsOfFace(const SMikkTSpaceContext * pContext, const int face_num)
1996 {
1997         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
1998         return pMesh->mface[face_num].v4!=0 ? 4 : 3;
1999 }
2000
2001 static void GetPosition(const SMikkTSpaceContext * pContext, float fPos[], const int face_num, const int vert_index)
2002 {
2003         //assert(vert_index>=0 && vert_index<4);
2004         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
2005         const float *co= pMesh->mvert[(&pMesh->mface[face_num].v1)[vert_index]].co;
2006         copy_v3_v3(fPos, co);
2007 }
2008
2009 static void GetTextureCoordinate(const SMikkTSpaceContext * pContext, float fUV[], const int face_num, const int vert_index)
2010 {
2011         //assert(vert_index>=0 && vert_index<4);
2012         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
2013
2014         if(pMesh->mtface!=NULL) {
2015                 float * uv = pMesh->mtface[face_num].uv[vert_index];
2016                 fUV[0]=uv[0]; fUV[1]=uv[1];
2017         }
2018         else {
2019                 const float *orco= pMesh->orco[(&pMesh->mface[face_num].v1)[vert_index]];
2020                 map_to_sphere( &fUV[0], &fUV[1], orco[0], orco[1], orco[2]);
2021         }
2022 }
2023
2024 static void GetNormal(const SMikkTSpaceContext * pContext, float fNorm[], const int face_num, const int vert_index)
2025 {
2026         //assert(vert_index>=0 && vert_index<4);
2027         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
2028
2029         const int smoothnormal = (pMesh->mface[face_num].flag & ME_SMOOTH);
2030         if(!smoothnormal) {     // flat
2031                 if(pMesh->precomputedFaceNormals) {
2032                         copy_v3_v3(fNorm, &pMesh->precomputedFaceNormals[3*face_num]);
2033                 }
2034                 else {
2035                         MFace *mf= &pMesh->mface[face_num];
2036                         float *p0= pMesh->mvert[mf->v1].co;
2037                         float *p1= pMesh->mvert[mf->v2].co;
2038                         float *p2= pMesh->mvert[mf->v3].co;
2039
2040                         if(mf->v4) {
2041                                 float *p3 = pMesh->mvert[mf->v4].co;
2042                                 normal_quad_v3(fNorm, p0, p1, p2, p3);
2043                         }
2044                         else {
2045                                 normal_tri_v3(fNorm, p0, p1, p2);
2046                         }
2047                 }
2048         }
2049         else {
2050                 const short *no= pMesh->mvert[(&pMesh->mface[face_num].v1)[vert_index]].no;
2051                 normal_short_to_float_v3(fNorm, no);
2052         }
2053 }
2054 static void SetTSpace(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int face_num, const int iVert)
2055 {
2056         //assert(vert_index>=0 && vert_index<4);
2057         SGLSLMeshToTangent * pMesh = (SGLSLMeshToTangent *) pContext->m_pUserData;
2058         float * pRes = pMesh->tangent[4*face_num+iVert];
2059         copy_v3_v3(pRes, fvTangent);
2060         pRes[3]=fSign;
2061 }
2062
2063
2064 void DM_add_tangent_layer(DerivedMesh *dm)
2065 {
2066         /* mesh vars */
2067         MTFace *mtface, *tf;
2068         MFace *mface, *mf;
2069         MVert *mvert, *v1, *v2, *v3, *v4;
2070         MemArena *arena= NULL;
2071         VertexTangent **vtangents= NULL;
2072         float (*orco)[3]= NULL, (*tangent)[4];
2073         float *uv1, *uv2, *uv3, *uv4, *vtang;
2074         float fno[3], tang[3], uv[4][2];
2075         int i, j, len, mf_vi[4], totvert, totface, iCalcNewMethod;
2076         float *nors;
2077
2078         if(CustomData_get_layer_index(&dm->faceData, CD_TANGENT) != -1)
2079                 return;
2080
2081         nors = dm->getTessFaceDataArray(dm, CD_NORMAL);
2082
2083         /* check we have all the needed layers */
2084         totvert= dm->getNumVerts(dm);
2085         totface= dm->getNumTessFaces(dm);
2086
2087         mvert= dm->getVertArray(dm);
2088         mface= dm->getTessFaceArray(dm);
2089         mtface= dm->getTessFaceDataArray(dm, CD_MTFACE);
2090
2091         if(!mtface) {
2092                 orco= dm->getVertDataArray(dm, CD_ORCO);
2093                 if(!orco)
2094                         return;
2095         }
2096         
2097         /* create tangent layer */
2098         DM_add_tessface_layer(dm, CD_TANGENT, CD_CALLOC, NULL);
2099         tangent= DM_get_tessface_data_layer(dm, CD_TANGENT);
2100         
2101         /* allocate some space */
2102         arena= BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "tangent layer arena");
2103         BLI_memarena_use_calloc(arena);
2104         vtangents= MEM_callocN(sizeof(VertexTangent*)*totvert, "VertexTangent");
2105
2106         // new computation method
2107         iCalcNewMethod = 1;
2108         if(iCalcNewMethod != 0) {
2109                 SGLSLMeshToTangent mesh2tangent= {0};
2110                 SMikkTSpaceContext sContext= {0};
2111                 SMikkTSpaceInterface sInterface= {0};
2112
2113                 mesh2tangent.precomputedFaceNormals = nors;
2114                 mesh2tangent.mtface = mtface;
2115                 mesh2tangent.mface = mface;
2116                 mesh2tangent.mvert = mvert;
2117                 mesh2tangent.orco = orco;
2118                 mesh2tangent.tangent = tangent;
2119                 mesh2tangent.numTessFaces = totface;
2120
2121                 sContext.m_pUserData = &mesh2tangent;
2122                 sContext.m_pInterface = &sInterface;
2123                 sInterface.m_getNumFaces = GetNumFaces;
2124                 sInterface.m_getNumVerticesOfFace = GetNumVertsOfFace;
2125                 sInterface.m_getPosition = GetPosition;
2126                 sInterface.m_getTexCoord = GetTextureCoordinate;
2127                 sInterface.m_getNormal = GetNormal;
2128                 sInterface.m_setTSpaceBasic = SetTSpace;
2129
2130                 // 0 if failed
2131                 iCalcNewMethod = genTangSpaceDefault(&sContext);
2132         }
2133
2134         if(!iCalcNewMethod) {
2135                 /* sum tangents at connected vertices */
2136                 for(i=0, tf=mtface, mf=mface; i < totface; mf++, tf++, i++) {
2137                         v1= &mvert[mf->v1];
2138                         v2= &mvert[mf->v2];
2139                         v3= &mvert[mf->v3];
2140
2141                         if (mf->v4) {
2142                                 v4= &mvert[mf->v4];
2143                                 normal_quad_v3( fno,v4->co, v3->co, v2->co, v1->co);
2144                         }
2145                         else {
2146                                 v4= NULL;
2147                                 normal_tri_v3( fno,v3->co, v2->co, v1->co);
2148                         }
2149                 
2150                         if(mtface) {
2151                                 uv1= tf->uv[0];
2152                                 uv2= tf->uv[1];
2153                                 uv3= tf->uv[2];
2154                                 uv4= tf->uv[3];
2155                         }
2156                         else {
2157                                 uv1= uv[0]; uv2= uv[1]; uv3= uv[2]; uv4= uv[3];
2158                                 map_to_sphere( &uv[0][0], &uv[0][1],orco[mf->v1][0], orco[mf->v1][1], orco[mf->v1][2]);
2159                                 map_to_sphere( &uv[1][0], &uv[1][1],orco[mf->v2][0], orco[mf->v2][1], orco[mf->v2][2]);
2160                                 map_to_sphere( &uv[2][0], &uv[2][1],orco[mf->v3][0], orco[mf->v3][1], orco[mf->v3][2]);
2161                                 if(v4)
2162                                         map_to_sphere( &uv[3][0], &uv[3][1],orco[mf->v4][0], orco[mf->v4][1], orco[mf->v4][2]);
2163                         }
2164                 
2165                         tangent_from_uv(uv1, uv2, uv3, v1->co, v2->co, v3->co, fno, tang);
2166                         sum_or_add_vertex_tangent(arena, &vtangents[mf->v1], tang, uv1);
2167                         sum_or_add_vertex_tangent(arena, &vtangents[mf->v2], tang, uv2);
2168                         sum_or_add_vertex_tangent(arena, &vtangents[mf->v3], tang, uv3);
2169                 
2170                         if(mf->v4) {
2171                                 v4= &mvert[mf->v4];
2172                         
2173                                 tangent_from_uv(uv1, uv3, uv4, v1->co, v3->co, v4->co, fno, tang);
2174                                 sum_or_add_vertex_tangent(arena, &vtangents[mf->v1], tang, uv1);
2175                                 sum_or_add_vertex_tangent(arena, &vtangents[mf->v3], tang, uv3);
2176                                 sum_or_add_vertex_tangent(arena, &vtangents[mf->v4], tang, uv4);
2177                         }
2178                 }
2179         
2180                 /* write tangent to layer */
2181                 for(i=0, tf=mtface, mf=mface; i < totface; mf++, tf++, i++, tangent+=4) {
2182                         len= (mf->v4)? 4 : 3; 
2183
2184                         if(mtface == NULL) {
2185                                 map_to_sphere( &uv[0][0], &uv[0][1],orco[mf->v1][0], orco[mf->v1][1], orco[mf->v1][2]);
2186                                 map_to_sphere( &uv[1][0], &uv[1][1],orco[mf->v2][0], orco[mf->v2][1], orco[mf->v2][2]);
2187                                 map_to_sphere( &uv[2][0], &uv[2][1],orco[mf->v3][0], orco[mf->v3][1], orco[mf->v3][2]);
2188                                 if(len==4)
2189                                         map_to_sphere( &uv[3][0], &uv[3][1],orco[mf->v4][0], orco[mf->v4][1], orco[mf->v4][2]);
2190                         }
2191                 
2192                         mf_vi[0]= mf->v1;
2193                         mf_vi[1]= mf->v2;
2194                         mf_vi[2]= mf->v3;
2195                         mf_vi[3]= mf->v4;
2196                 
2197                         for(j=0; j<len; j++) {
2198                                 vtang= find_vertex_tangent(vtangents[mf_vi[j]], mtface ? tf->uv[j] : uv[j]);
2199                                 normalize_v3_v3(tangent[j], vtang);
2200                                 ((float *) tangent[j])[3]=1.0f;
2201                         }
2202                 }
2203         }
2204         
2205         BLI_memarena_free(arena);
2206         MEM_freeN(vtangents);
2207 }
2208
2209 void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs, DMVertexAttribs *attribs)
2210 {
2211         CustomData *vdata, *fdata, *tfdata = NULL;
2212         int a, b, layer;
2213
2214         /* From the layers requested by the GLSL shader, figure out which ones are
2215          * actually available for this derivedmesh, and retrieve the pointers */
2216
2217         memset(attribs, 0, sizeof(DMVertexAttribs));
2218
2219         vdata = &dm->vertData;
2220         fdata = tfdata = dm->getTessFaceDataLayout(dm);
2221         
2222         /* add a tangent layer if necessary */
2223         for(b = 0; b < gattribs->totlayer; b++)
2224                 if(gattribs->layer[b].type == CD_TANGENT)
2225                         if(CustomData_get_layer_index(fdata, CD_TANGENT) == -1)
2226                                 DM_add_tangent_layer(dm);
2227
2228         for(b = 0; b < gattribs->totlayer; b++) {
2229                 if(gattribs->layer[b].type == CD_MTFACE) {
2230                         /* uv coordinates */
2231                         if(gattribs->layer[b].name[0])
2232                                 layer = CustomData_get_named_layer_index(tfdata, CD_MTFACE,
2233                                         gattribs->layer[b].name);
2234                         else
2235                                 layer = CustomData_get_active_layer_index(tfdata, CD_MTFACE);
2236
2237                         if(layer != -1) {
2238                                 a = attribs->tottface++;
2239
2240                                 attribs->tface[a].array = tfdata->layers[layer].data;
2241                                 attribs->tface[a].emOffset = tfdata->layers[layer].offset;
2242                                 attribs->tface[a].glIndex = gattribs->layer[b].glindex;
2243                         } /*else {
2244                                 int player;
2245                                 CustomData *pdata = dm->getPolyDataLayout(dm);
2246                                 
2247                                 if(gattribs->layer[b].name[0])
2248                                         player = CustomData_get_named_layer_index(pdata, CD_MTEXPOLY,
2249                                                 gattribs->layer[b].name);
2250                                 else
2251                                         player = CustomData_get_active_layer_index(pdata, CD_MTEXPOLY);
2252                                 
2253                                 if (player != -1) {
2254                                         a = attribs->tottface++;
2255         
2256                                         attribs->tface[a].array = NULL;
2257                                         attribs->tface[a].emOffset = pdata->layers[layer].offset;
2258                                         attribs->tface[a].glIndex = gattribs->layer[b].glindex;
2259                                         attribs->tface[a].glTexco = gattribs->layer[b].gltexco;
2260                                         
2261                                 }
2262                         }*/
2263                 }
2264                 else if(gattribs->layer[b].type == CD_MCOL) {
2265                         /* vertex colors */
2266                         if(gattribs->layer[b].name[0])
2267                                 layer = CustomData_get_named_layer_index(tfdata, CD_MCOL,
2268                                         gattribs->layer[b].name);
2269                         else
2270                                 layer = CustomData_get_active_layer_index(tfdata, CD_MCOL);
2271
2272                         if(layer != -1) {
2273                                 a = attribs->totmcol++;
2274
2275                                 attribs->mcol[a].array = tfdata->layers[layer].data;
2276                                 attribs->mcol[a].emOffset = tfdata->layers[layer].offset;
2277                                 attribs->mcol[a].glIndex = gattribs->layer[b].glindex;
2278                         }
2279                 }
2280                 else if(gattribs->layer[b].type == CD_TANGENT) {
2281                         /* tangents */
2282                         layer = CustomData_get_layer_index(fdata, CD_TANGENT);
2283
2284                         if(layer != -1) {
2285                                 attribs->tottang = 1;
2286
2287                                 attribs->tang.array = fdata->layers[layer].data;
2288                                 attribs->tang.emOffset = fdata->layers[layer].offset;
2289                                 attribs->tang.glIndex = gattribs->layer[b].glindex;
2290                         }
2291                 }
2292                 else if(gattribs->layer[b].type == CD_ORCO) {
2293                         /* original coordinates */
2294                         layer = CustomData_get_layer_index(vdata, CD_ORCO);
2295
2296                         if(layer != -1) {
2297                                 attribs->totorco = 1;
2298
2299                                 attribs->orco.array = vdata->layers[layer].data;
2300                                 attribs->orco.emOffset = vdata->layers[layer].offset;
2301                                 attribs->orco.glIndex = gattribs->layer[b].glindex;
2302                                 attribs->orco.glTexco = gattribs->layer[b].gltexco;
2303                         }
2304                 }
2305         }
2306 }
2307
2308 /* Set object's bounding box based on DerivedMesh min/max data */
2309 void DM_set_object_boundbox(Object *ob, DerivedMesh *dm)
2310 {
2311         float min[3], max[3];
2312
2313         INIT_MINMAX(min, max);
2314
2315         dm->getMinMax(dm, min, max);
2316
2317         if(!ob->bb)
2318                 ob->bb= MEM_callocN(sizeof(BoundBox), "DM-BoundBox");
2319
2320         boundbox_set_from_min_max(ob->bb, min, max);
2321 }
2322
2323 /* --- NAVMESH (begin) --- */
2324 #ifdef WITH_GAMEENGINE
2325
2326 BM_INLINE int navmesh_bit(int a, int b)
2327 {
2328         return (a & (1 << b)) >> b;
2329 }
2330
2331 BM_INLINE void navmesh_intToCol(int i, float col[3])
2332 {
2333         int     r = navmesh_bit(i, 0) + navmesh_bit(i, 3) * 2 + 1;
2334         int     g = navmesh_bit(i, 1) + navmesh_bit(i, 4) * 2 + 1;
2335         int     b = navmesh_bit(i, 2) + navmesh_bit(i, 5) * 2 + 1;
2336         col[0] = 1 - r*63.0f/255.0f;
2337         col[1] = 1 - g*63.0f/255.0f;
2338         col[2] = 1 - b*63.0f/255.0f;
2339 }
2340
2341 static void navmesh_drawColored(DerivedMesh *dm)
2342 {
2343         int a, glmode;
2344         MVert *mvert = (MVert *)CustomData_get_layer(&dm->vertData, CD_MVERT);
2345         MFace *mface = (MFace *)CustomData_get_layer(&dm->faceData, CD_MFACE);
2346         int *polygonIdx = (int *)CustomData_get_layer(&dm->faceData, CD_RECAST);
2347         float col[3];
2348
2349         if (!polygonIdx)
2350                 return;
2351
2352         /*
2353         //UI_ThemeColor(TH_WIRE);
2354         glDisable(GL_LIGHTING);
2355         glLineWidth(2.0);
2356         dm->drawEdges(dm, 0, 1);
2357         glLineWidth(1.0);
2358         glEnable(GL_LIGHTING);*/
2359
2360         glDisable(GL_LIGHTING);
2361         /*  if(GPU_buffer_legacy(dm) ) */ { /* TODO - VBO draw code, not high priority - campbell */
2362                 DEBUG_VBO( "Using legacy code. drawNavMeshColored\n" );
2363                 //glShadeModel(GL_SMOOTH);
2364                 glBegin(glmode = GL_QUADS);
2365                 for(a = 0; a < dm->numTessFaceData; a++, mface++) {
2366                         int new_glmode = mface->v4?GL_QUADS:GL_TRIANGLES;
2367                         int pi = polygonIdx[a];
2368                         if (pi <= 0) {
2369                                 zero_v3(col);
2370                         }
2371                         else {
2372                                 navmesh_intToCol(pi, col);
2373                         }
2374
2375                         if(new_glmode != glmode) {
2376                                 glEnd();
2377                                 glBegin(glmode = new_glmode);
2378                         }
2379                         glColor3fv(col);
2380                         glVertex3fv(mvert[mface->v1].co);
2381                         glVertex3fv(mvert[mface->v2].co);
2382                         glVertex3fv(mvert[mface->v3].co);
2383                         if(mface->v4) {
2384                                 glVertex3fv(mvert[mface->v4].co);
2385                         }
2386                 }
2387                 glEnd();
2388         }
2389         glEnable(GL_LIGHTING);
2390 }
2391
2392 static void navmesh_DM_drawFacesTex(DerivedMesh *dm,
2393                         int (*setDrawOptions)(MTFace *tface, int has_mcol, int matnr),
2394                         int (*compareDrawOptions)(void *userData, int cur_index, int next_index),
2395                         void *userData)
2396 {
2397         (void) setDrawOptions;
2398         (void) compareDrawOptions;
2399         (void) userData;
2400
2401         navmesh_drawColored(dm);
2402 }
2403
2404 static void navmesh_DM_drawFacesSolid(DerivedMesh *dm,
2405                                       float (*partial_redraw_planes)[4],
2406                                       int UNUSED(fast), int (*setMaterial)(int, void *attribs))
2407 {
2408         (void) partial_redraw_planes;
2409         (void) setMaterial;
2410
2411         //drawFacesSolid_original(dm, partial_redraw_planes, fast, setMaterial);
2412         navmesh_drawColored(dm);
2413 }
2414
2415 static DerivedMesh *navmesh_dm_createNavMeshForVisualization(DerivedMesh *dm)
2416 {
2417         DerivedMesh *result;
2418         int maxFaces = dm->getNumPolys(dm);
2419         int *recastData;
2420         int vertsPerPoly=0, nverts=0, ndtris=0, npolys=0;
2421         float* verts=NULL;
2422         unsigned short *dtris=NULL, *dmeshes=NULL, *polys=NULL;
2423         int *dtrisToPolysMap=NULL, *dtrisToTrisMap=NULL, *trisToFacesMap=NULL;
2424         int res;
2425
2426         result = CDDM_copy(dm, 0);
2427         if (!CustomData_has_layer(&result->faceData, CD_RECAST)) {
2428                 int *sourceRecastData = (int*)CustomData_get_layer(&dm->faceData, CD_RECAST);
2429                 if (sourceRecastData) {
2430                         CustomData_add_layer_named(&result->faceData, CD_RECAST, CD_DUPLICATE,
2431                                                    sourceRecastData, maxFaces, "recastData");
2432                 }
2433         }
2434         recastData = (int*)CustomData_get_layer(&result->faceData, CD_RECAST);
2435
2436         /* note: This is not good design! - really should not be doing this */
2437         result->drawFacesTex =  navmesh_DM_drawFacesTex;
2438         result->drawFacesSolid = navmesh_DM_drawFacesSolid;
2439
2440
2441         /* process mesh */
2442         res  = buildNavMeshDataByDerivedMesh(dm, &vertsPerPoly, &nverts, &verts, &ndtris, &dtris,
2443                                              &npolys, &dmeshes, &polys, &dtrisToPolysMap, &dtrisToTrisMap,
2444                                              &trisToFacesMap);
2445         if (res) {
2446                 size_t polyIdx;
2447
2448                 /* invalidate concave polygon */
2449                 for (polyIdx=0; polyIdx<(size_t)npolys; polyIdx++) {
2450                         unsigned short* poly = &polys[polyIdx*2*vertsPerPoly];
2451                         if (!polyIsConvex(poly, vertsPerPoly, verts)) {
2452                                 /* set negative polygon idx to all faces */
2453                                 unsigned short *dmesh = &dmeshes[4*polyIdx];
2454                                 unsigned short tbase = dmesh[2];
2455                                 unsigned short tnum = dmesh[3];
2456                                 unsigned short ti;
2457
2458                                 for (ti=0; ti<tnum; ti++) {
2459                                         unsigned short triidx = dtrisToTrisMap[tbase+ti];
2460                                         unsigned short faceidx = trisToFacesMap[triidx];
2461                                         if (recastData[faceidx] > 0) {
2462                                                 recastData[faceidx] = -recastData[faceidx];
2463                                         }
2464                                 }
2465                         }
2466                 }
2467         }
2468         else {
2469                 printf("Error during creation polygon infos\n");
2470         }
2471
2472         /* clean up */
2473         if (verts!=NULL)
2474                 MEM_freeN(verts);
2475         if (dtris!=NULL)
2476                 MEM_freeN(dtris);
2477         if (dmeshes!=NULL)
2478                 MEM_freeN(dmeshes);
2479         if (polys!=NULL)
2480                 MEM_freeN(polys);
2481         if (dtrisToPolysMap!=NULL)
2482                 MEM_freeN(dtrisToPolysMap);
2483         if (dtrisToTrisMap!=NULL)
2484                 MEM_freeN(dtrisToTrisMap);
2485         if (trisToFacesMap!=NULL)
2486                 MEM_freeN(trisToFacesMap);
2487
2488         return result;
2489 }
2490
2491 #endif /* WITH_GAMEENGINE */
2492
2493 /* --- NAVMESH (end) --- */