eb723dcca6c13450c1beab3b62b224a99b76b5b8
[blender.git] / source / blender / editors / object / object_modifier.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation, 2009
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include <math.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_curve_types.h"
35 #include "DNA_mesh_types.h"
36 #include "DNA_meshdata_types.h"
37 #include "DNA_modifier_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_object_force.h"
40 #include "DNA_scene_types.h"
41
42 #include "BLI_listbase.h"
43
44 #include "BKE_curve.h"
45 #include "BKE_context.h"
46 #include "BKE_depsgraph.h"
47 #include "BKE_displist.h"
48 #include "BKE_DerivedMesh.h"
49 #include "BKE_effect.h"
50 #include "BKE_global.h"
51 #include "BKE_lattice.h"
52 #include "BKE_mesh.h"
53 #include "BKE_modifier.h"
54 #include "BKE_multires.h"
55 #include "BKE_report.h"
56 #include "BKE_object.h"
57 #include "BKE_particle.h"
58 #include "BKE_softbody.h"
59 #include "BKE_utildefines.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63 #include "RNA_enum_types.h"
64
65 #include "ED_screen.h"
66
67 #include "WM_api.h"
68 #include "WM_types.h"
69
70 #include "object_intern.h"
71
72 /******************************** API ****************************/
73
74 int ED_object_modifier_add(ReportList *reports, Scene *scene, Object *ob, int type)
75 {
76         ModifierData *md;
77         ModifierTypeInfo *mti = modifierType_getInfo(type);
78
79         if(mti->flags&eModifierTypeFlag_Single) {
80                 if(modifiers_findByType(ob, type)) {
81                         BKE_report(reports, RPT_WARNING, "Only one modifier of this type allowed.");
82                         return 0;
83                 }
84         }
85
86         if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
87                 md = ob->modifiers.first;
88
89                 while(md && modifierType_getInfo(md->type)->type==eModifierTypeType_OnlyDeform)
90                         md = md->next;
91
92                 BLI_insertlinkbefore(&ob->modifiers, md, modifier_new(type));
93         }
94         else
95                 BLI_addtail(&ob->modifiers, modifier_new(type));
96         
97         /* special cases */
98         if(type == eModifierType_Softbody) {
99                 if(!ob->soft) {
100                         ob->soft= sbNew(scene);
101                         ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
102                 }
103         }
104         else if(type == eModifierType_Collision) {
105                 if(!ob->pd)
106                         ob->pd= object_add_collision_fields();
107
108                 ob->pd->deflect= 1;
109         DAG_scene_sort(scene);
110         }
111         else if(type == eModifierType_Surface)
112         DAG_scene_sort(scene);
113
114         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
115
116         return 1;
117 }
118
119 int ED_object_modifier_remove(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
120 {
121         ModifierData *obmd;
122
123         /* It seems on rapid delete it is possible to
124          * get called twice on same modifier, so make
125          * sure it is in list. */
126         for(obmd=ob->modifiers.first; obmd; obmd=obmd->next)
127                 if(obmd==md)
128                         break;
129         
130         if(!obmd)
131                 return 0;
132
133         /* special cases */
134         if(md->type == eModifierType_ParticleSystem) {
135                 ParticleSystemModifierData *psmd=(ParticleSystemModifierData*)md;
136
137                 BLI_remlink(&ob->particlesystem, psmd->psys);
138                 psys_free(ob, psmd->psys);
139         }
140         else if(md->type == eModifierType_Softbody) {
141                 if(ob->soft) {
142                         sbFree(ob->soft);
143                         ob->soft= NULL;
144                         ob->softflag= 0;
145                 }
146         }
147         else if(md->type == eModifierType_Collision) {
148                 if(ob->pd)
149                         ob->pd->deflect= 0;
150
151         DAG_scene_sort(scene);
152         }
153         else if(md->type == eModifierType_Surface) {
154                 if(ob->pd)
155                         ob->pd->flag &= ~PFIELD_SURFACE;
156
157         DAG_scene_sort(scene);
158         }
159
160         BLI_remlink(&ob->modifiers, md);
161         modifier_free(md);
162
163         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
164
165         return 1;
166 }
167
168 int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
169 {
170         if(md->prev) {
171                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
172
173                 if(mti->type!=eModifierTypeType_OnlyDeform) {
174                         ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);
175
176                         if(nmti->flags&eModifierTypeFlag_RequiresOriginalData) {
177                                 BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data.");
178                                 return 0;
179                         }
180                 }
181
182                 BLI_remlink(&ob->modifiers, md);
183                 BLI_insertlink(&ob->modifiers, md->prev->prev, md);
184         }
185
186         return 1;
187 }
188
189 int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
190 {
191         if(md->next) {
192                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
193
194                 if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
195                         ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);
196
197                         if(nmti->type!=eModifierTypeType_OnlyDeform) {
198                                 BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier.");
199                                 return 0;
200                         }
201                 }
202
203                 BLI_remlink(&ob->modifiers, md);
204                 BLI_insertlink(&ob->modifiers, md->next, md);
205         }
206
207         return 1;
208 }
209
210 int ED_object_modifier_convert(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
211 {
212         Object *obn;
213         ParticleSystem *psys;
214         ParticleCacheKey *key, **cache;
215         ParticleSettings *part;
216         Mesh *me;
217         MVert *mvert;
218         MEdge *medge;
219         int a, k, kmax;
220         int totvert=0, totedge=0, cvert=0;
221         int totpart=0, totchild=0;
222
223         if(md->type != eModifierType_ParticleSystem) return 0;
224         if(G.f & G_PARTICLEEDIT) return 0;
225
226         psys=((ParticleSystemModifierData *)md)->psys;
227         part= psys->part;
228
229         if(part->ren_as == PART_DRAW_GR || part->ren_as == PART_DRAW_OB) {
230                 ; // XXX make_object_duplilist_real(NULL);
231         }
232         else {
233                 if(part->ren_as != PART_DRAW_PATH || psys->pathcache == 0)
234                         return 0;
235
236                 totpart= psys->totcached;
237                 totchild= psys->totchildcache;
238
239                 if(totchild && (part->draw&PART_DRAW_PARENT)==0)
240                         totpart= 0;
241
242                 /* count */
243                 cache= psys->pathcache;
244                 for(a=0; a<totpart; a++) {
245                         key= cache[a];
246                         totvert+= key->steps+1;
247                         totedge+= key->steps;
248                 }
249
250                 cache= psys->childcache;
251                 for(a=0; a<totchild; a++) {
252                         key= cache[a];
253                         totvert+= key->steps+1;
254                         totedge+= key->steps;
255                 }
256
257                 if(totvert==0) return 0;
258
259                 /* add new mesh */
260                 obn= add_object(scene, OB_MESH);
261                 me= obn->data;
262                 
263                 me->totvert= totvert;
264                 me->totedge= totedge;
265                 
266                 me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
267                 me->medge= CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
268                 me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
269                 
270                 mvert= me->mvert;
271                 medge= me->medge;
272
273                 /* copy coordinates */
274                 cache= psys->pathcache;
275                 for(a=0; a<totpart; a++) {
276                         key= cache[a];
277                         kmax= key->steps;
278                         for(k=0; k<=kmax; k++,key++,cvert++,mvert++) {
279                                 VECCOPY(mvert->co,key->co);
280                                 if(k) {
281                                         medge->v1= cvert-1;
282                                         medge->v2= cvert;
283                                         medge->flag= ME_EDGEDRAW|ME_EDGERENDER|ME_LOOSEEDGE;
284                                         medge++;
285                                 }
286                         }
287                 }
288
289                 cache=psys->childcache;
290                 for(a=0; a<totchild; a++) {
291                         key=cache[a];
292                         kmax=key->steps;
293                         for(k=0; k<=kmax; k++,key++,cvert++,mvert++) {
294                                 VECCOPY(mvert->co,key->co);
295                                 if(k) {
296                                         medge->v1=cvert-1;
297                                         medge->v2=cvert;
298                                         medge->flag= ME_EDGEDRAW|ME_EDGERENDER|ME_LOOSEEDGE;
299                                         medge++;
300                                 }
301                         }
302                 }
303         }
304
305         DAG_scene_sort(scene);
306
307         return 1;
308 }
309
310 int ED_object_modifier_apply(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
311 {
312         DerivedMesh *dm;
313         Mesh *me = ob->data;
314         int converted = 0;
315
316         if (scene->obedit) {
317                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied in editmode");
318                 return 0;
319         } else if (((ID*) ob->data)->us>1) {
320                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied to multi-user data");
321                 return 0;
322         }
323
324         if (md!=ob->modifiers.first)
325                 BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected.");
326
327         if (ob->type==OB_MESH) {
328                 if(me->key) {
329                         BKE_report(reports, RPT_ERROR, "Modifier cannot be applied to Mesh with Shape Keys");
330                         return 0;
331                 }
332         
333                 mesh_pmv_off(ob, me);
334
335                /* Multires: ensure that recent sculpting is applied */
336                if(md->type == eModifierType_Multires)
337                        multires_force_update(ob);
338         
339                 dm = mesh_create_derived_for_modifier(scene, ob, md);
340                 if (!dm) {
341                         BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
342                         return 0;
343                 }
344
345                 DM_to_mesh(dm, me);
346                 converted = 1;
347
348                 dm->release(dm);
349         } 
350         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
351                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
352                 Curve *cu = ob->data;
353                 int numVerts;
354                 float (*vertexCos)[3];
355
356                 BKE_report(reports, RPT_INFO, "Applied modifier only changed CV points, not tesselated/bevel vertices");
357
358                 if (!(md->mode&eModifierMode_Realtime) || (mti->isDisabled && mti->isDisabled(md))) {
359                         BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
360                         return 0;
361                 }
362
363                 vertexCos = curve_getVertexCos(cu, &cu->nurb, &numVerts);
364                 mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0, 0);
365                 curve_applyVertexCos(cu, &cu->nurb, vertexCos);
366
367                 converted = 1;
368
369                 MEM_freeN(vertexCos);
370
371                 DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
372         }
373         else {
374                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
375                 return 0;
376         }
377
378         if (converted) {
379                 BLI_remlink(&ob->modifiers, md);
380                 modifier_free(md);
381
382                 return 1;
383         }
384
385         return 0;
386 }
387
388 int ED_object_modifier_copy(ReportList *reports, Object *ob, ModifierData *md)
389 {
390         ModifierData *nmd;
391         
392         nmd = modifier_new(md->type);
393         modifier_copyData(md, nmd);
394         BLI_insertlink(&ob->modifiers, md, nmd);
395
396         return 1;
397 }
398
399 /***************************** OPERATORS ****************************/
400
401 /************************ add modifier operator *********************/
402
403 static int modifier_add_exec(bContext *C, wmOperator *op)
404 {
405         Scene *scene= CTX_data_scene(C);
406     Object *ob = CTX_data_active_object(C);
407         int type= RNA_enum_get(op->ptr, "type");
408
409         if(!ED_object_modifier_add(op->reports, scene, ob, type))
410                 return OPERATOR_CANCELLED;
411
412         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
413         
414         return OPERATOR_FINISHED;
415 }
416
417 void OBJECT_OT_modifier_add(wmOperatorType *ot)
418 {
419         /* identifiers */
420         ot->name= "Add Modifier";
421         ot->description = "Add a modifier to the active object.";
422         ot->idname= "OBJECT_OT_modifier_add";
423         
424         /* api callbacks */
425         ot->invoke= WM_menu_invoke;
426         ot->exec= modifier_add_exec;
427         
428         ot->poll= ED_operator_object_active;
429         
430         /* flags */
431         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
432         
433         /* XXX only some types should be here */
434         RNA_def_enum(ot->srna, "type", modifier_type_items, 0, "Type", "");
435 }
436
437 /************************ remove modifier operator *********************/
438
439 static int modifier_remove_exec(bContext *C, wmOperator *op)
440 {
441         Scene *scene= CTX_data_scene(C);
442         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
443         Object *ob= ptr.id.data;
444         ModifierData *md= ptr.data;
445
446         if(!ob || !md || !ED_object_modifier_remove(op->reports, scene, ob, md))
447                 return OPERATOR_CANCELLED;
448
449         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
450         
451         return OPERATOR_FINISHED;
452 }
453
454 void OBJECT_OT_modifier_remove(wmOperatorType *ot)
455 {
456         ot->name= "Remove Modifier";
457         ot->description= "Remove a modifier from the active object.";
458         ot->idname= "OBJECT_OT_modifier_remove";
459         ot->poll= ED_operator_object_active;
460
461         ot->exec= modifier_remove_exec;
462         
463         /* flags */
464         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
465 }
466
467 /************************ move up modifier operator *********************/
468
469 static int modifier_move_up_exec(bContext *C, wmOperator *op)
470 {
471         Scene *scene= CTX_data_scene(C);
472         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
473         Object *ob= ptr.id.data;
474         ModifierData *md= ptr.data;
475
476         if(!ob || !md || !ED_object_modifier_move_up(op->reports, ob, md))
477                 return OPERATOR_CANCELLED;
478
479         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
480         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
481         
482         return OPERATOR_FINISHED;
483 }
484
485 void OBJECT_OT_modifier_move_up(wmOperatorType *ot)
486 {
487         ot->name= "Move Up Modifier";
488         ot->description= "Move modifier up in the stack.";
489         ot->idname= "OBJECT_OT_modifier_move_up";
490         ot->poll= ED_operator_object_active;
491
492         ot->exec= modifier_move_up_exec;
493         
494         /* flags */
495         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
496 }
497
498 /************************ move down modifier operator *********************/
499
500 static int modifier_move_down_exec(bContext *C, wmOperator *op)
501 {
502         Scene *scene= CTX_data_scene(C);
503         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
504         Object *ob= ptr.id.data;
505         ModifierData *md= ptr.data;
506
507         if(!ob || !md || !ED_object_modifier_move_down(op->reports, ob, md))
508                 return OPERATOR_CANCELLED;
509
510         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
511         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
512         
513         return OPERATOR_FINISHED;
514 }
515
516 void OBJECT_OT_modifier_move_down(wmOperatorType *ot)
517 {
518         ot->name= "Move Down Modifier";
519         ot->description= "Move modifier down in the stack.";
520         ot->idname= "OBJECT_OT_modifier_move_down";
521         ot->poll= ED_operator_object_active;
522
523         ot->exec= modifier_move_down_exec;
524         
525         /* flags */
526         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
527 }
528
529 /************************ apply modifier operator *********************/
530
531 static int modifier_apply_exec(bContext *C, wmOperator *op)
532 {
533         Scene *scene= CTX_data_scene(C);
534         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
535         Object *ob= ptr.id.data;
536         ModifierData *md= ptr.data;
537
538         if(!ob || !md || !ED_object_modifier_apply(op->reports, scene, ob, md))
539                 return OPERATOR_CANCELLED;
540
541         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
542         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
543         
544         return OPERATOR_FINISHED;
545 }
546
547 void OBJECT_OT_modifier_apply(wmOperatorType *ot)
548 {
549         ot->name= "Apply Modifier";
550         ot->description= "Apply modifier and remove from the stack.";
551         ot->idname= "OBJECT_OT_modifier_apply";
552         ot->poll= ED_operator_object_active;
553
554         ot->exec= modifier_apply_exec;
555         
556         /* flags */
557         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
558 }
559
560 /************************ convert modifier operator *********************/
561
562 static int modifier_convert_exec(bContext *C, wmOperator *op)
563 {
564         Scene *scene= CTX_data_scene(C);
565         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
566         Object *ob= ptr.id.data;
567         ModifierData *md= ptr.data;
568
569         if(!ob || !md || !ED_object_modifier_convert(op->reports, scene, ob, md))
570                 return OPERATOR_CANCELLED;
571
572         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
573         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
574         
575         return OPERATOR_FINISHED;
576 }
577
578 void OBJECT_OT_modifier_convert(wmOperatorType *ot)
579 {
580         ot->name= "Convert Modifier";
581         ot->description= "Convert particles to a mesh object.";
582         ot->idname= "OBJECT_OT_modifier_convert";
583         ot->poll= ED_operator_object_active;
584
585         ot->exec= modifier_convert_exec;
586         
587         /* flags */
588         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
589 }
590
591 /************************ copy modifier operator *********************/
592
593 static int modifier_copy_exec(bContext *C, wmOperator *op)
594 {
595         Scene *scene= CTX_data_scene(C);
596         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
597         Object *ob= ptr.id.data;
598         ModifierData *md= ptr.data;
599
600         if(!ob || !md || !ED_object_modifier_copy(op->reports, ob, md))
601                 return OPERATOR_CANCELLED;
602
603         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
604         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
605         
606         return OPERATOR_FINISHED;
607 }
608
609 void OBJECT_OT_modifier_copy(wmOperatorType *ot)
610 {
611         ot->name= "Copy Modifier";
612         ot->description= "Duplicate modifier at the same position in the stack.";
613         ot->idname= "OBJECT_OT_modifier_copy";
614         ot->poll= ED_operator_object_active;
615
616         ot->exec= modifier_copy_exec;
617         
618         /* flags */
619         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
620 }
621
622 /****************** multires subdivide operator *********************/
623
624 static int multires_subdivide_exec(bContext *C, wmOperator *op)
625 {
626         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_MultiresModifier);
627         Object *ob= ptr.id.data;
628         MultiresModifierData *mmd= ptr.data;
629
630         if(mmd) {
631                 multiresModifier_subdivide(mmd, ob, 1, 0, mmd->simple);
632                 WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
633         }
634         
635         return OPERATOR_FINISHED;
636 }
637
638 void OBJECT_OT_multires_subdivide(wmOperatorType *ot)
639 {
640         ot->name= "Multires Subdivide";
641         ot->description= "Add a new level of subdivision.";
642         ot->idname= "OBJECT_OT_multires_subdivide";
643         ot->poll= ED_operator_object_active;
644
645         ot->exec= multires_subdivide_exec;
646         
647         /* flags */
648         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
649 }
650
651 /************************ mdef bind operator *********************/
652
653 static int modifier_mdef_bind_poll(bContext *C)
654 {
655         return CTX_data_pointer_get_type(C, "modifier", &RNA_MeshDeformModifier).data != NULL;
656 }
657
658 static int modifier_mdef_bind_exec(bContext *C, wmOperator *op)
659 {
660         Scene *scene= CTX_data_scene(C);
661         PointerRNA ptr= CTX_data_pointer_get(C, "modifier");
662         Object *ob= ptr.id.data;
663         MeshDeformModifierData *mmd= ptr.data;
664
665         if(mmd->bindcos) {
666                 if(mmd->bindweights) MEM_freeN(mmd->bindweights);
667                 if(mmd->bindcos) MEM_freeN(mmd->bindcos);
668                 if(mmd->dyngrid) MEM_freeN(mmd->dyngrid);
669                 if(mmd->dyninfluences) MEM_freeN(mmd->dyninfluences);
670                 if(mmd->dynverts) MEM_freeN(mmd->dynverts);
671                 mmd->bindweights= NULL;
672                 mmd->bindcos= NULL;
673                 mmd->dyngrid= NULL;
674                 mmd->dyninfluences= NULL;
675                 mmd->dynverts= NULL;
676                 mmd->totvert= 0;
677                 mmd->totcagevert= 0;
678                 mmd->totinfluence= 0;
679         }
680         else {
681                 DerivedMesh *dm;
682                 int mode= mmd->modifier.mode;
683
684                 /* force modifier to run, it will call binding routine */
685                 mmd->needbind= 1;
686                 mmd->modifier.mode |= eModifierMode_Realtime;
687
688                 if(ob->type == OB_MESH) {
689                         dm= mesh_create_derived_view(scene, ob, 0);
690                         dm->release(dm);
691                 }
692                 else if(ob->type == OB_LATTICE) {
693                         lattice_calc_modifiers(scene, ob);
694                 }
695                 else if(ob->type==OB_MBALL) {
696                         makeDispListMBall(scene, ob);
697                 }
698                 else if(ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
699                         makeDispListCurveTypes(scene, ob, 0);
700                 }
701
702                 mmd->needbind= 0;
703                 mmd->modifier.mode= mode;
704         }
705         
706         return OPERATOR_FINISHED;
707 }
708
709 void OBJECT_OT_modifier_mdef_bind(wmOperatorType *ot)
710 {
711         /* identifiers */
712         ot->name= "Mesh Deform Bind";
713         ot->description = "Bind mesh to cage in mesh deform modifier.";
714         ot->idname= "OBJECT_OT_modifier_mdef_bind";
715         
716         /* api callbacks */
717         ot->poll= modifier_mdef_bind_poll;
718         ot->exec= modifier_mdef_bind_exec;
719         
720         /* flags */
721         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
722 }
723
724 #if 0
725 static void modifiers_add(void *ob_v, int type)
726 {
727         Object *ob = ob_v;
728         ModifierTypeInfo *mti = modifierType_getInfo(type);
729         
730         if (mti->flags&eModifierTypeFlag_RequiresOriginalData) {
731                 ModifierData *md = ob->modifiers.first;
732
733                 while (md && modifierType_getInfo(md->type)->type==eModifierTypeType_OnlyDeform) {
734                         md = md->next;
735                 }
736
737                 BLI_insertlinkbefore(&ob->modifiers, md, modifier_new(type));
738         } else {
739                 BLI_addtail(&ob->modifiers, modifier_new(type));
740         }
741         ED_undo_push("Add modifier");
742 }
743
744 typedef struct MenuEntry {
745         char *name;
746         int ID;
747 } MenuEntry;
748
749 static int menuEntry_compare_names(const void *entry1, const void *entry2)
750 {
751         return strcmp(((MenuEntry *)entry1)->name, ((MenuEntry *)entry2)->name);
752 }
753
754 static uiBlock *modifiers_add_menu(void *ob_v)
755 {
756         Object *ob = ob_v;
757         uiBlock *block;
758         int i, yco=0;
759         int numEntries = 0;
760         MenuEntry entries[NUM_MODIFIER_TYPES];
761         
762         block= uiNewBlock(&curarea->uiblocks, "modifier_add_menu",
763                           UI_EMBOSSP, UI_HELV, curarea->win);
764         uiBlockSetButmFunc(block, modifiers_add, ob);
765
766         for (i=eModifierType_None+1; i<NUM_MODIFIER_TYPES; i++) {
767                 ModifierTypeInfo *mti = modifierType_getInfo(i);
768
769                 /* Only allow adding through appropriate other interfaces */
770                 if(ELEM(i, eModifierType_ParticleSystem, eModifierType_Surface)) continue;
771
772                 if((mti->flags&eModifierTypeFlag_AcceptsCVs) ||
773                    (ob->type==OB_MESH && (mti->flags&eModifierTypeFlag_AcceptsMesh))) {
774                         entries[numEntries].name = mti->name;
775                         entries[numEntries].ID = i;
776
777                         ++numEntries;
778                 }
779         }
780
781         qsort(entries, numEntries, sizeof(*entries), menuEntry_compare_names);
782
783
784         for(i = 0; i < numEntries; ++i)
785                 uiDefBut(block, BUTM, B_MODIFIER_RECALC, entries[i].name,
786                          0, yco -= 20, 160, 19, NULL, 0, 0, 1, entries[i].ID, "");
787
788         uiTextBoundsBlock(block, 50);
789         uiBlockSetDirection(block, UI_DOWN);
790
791         return block;
792 }
793 #endif
794
795 #if 0
796 static void modifiers_clearHookOffset(bContext *C, void *ob_v, void *md_v)
797 {
798         Object *ob = ob_v;
799         ModifierData *md = md_v;
800         HookModifierData *hmd = (HookModifierData*) md;
801         
802         if (hmd->object) {
803                 Mat4Invert(hmd->object->imat, hmd->object->obmat);
804                 Mat4MulSerie(hmd->parentinv, hmd->object->imat, ob->obmat, NULL, NULL, NULL, NULL, NULL, NULL);
805                 ED_undo_push(C, "Clear hook offset");
806         }
807 }
808
809 static void modifiers_cursorHookCenter(bContext *C, void *ob_v, void *md_v)
810 {
811         /* XXX 
812         Object *ob = ob_v;
813         ModifierData *md = md_v;
814         HookModifierData *hmd = (HookModifierData*) md;
815
816         if(G.vd) {
817                 float *curs = give_cursor();
818                 float bmat[3][3], imat[3][3];
819
820                 where_is_object(ob);
821         
822                 Mat3CpyMat4(bmat, ob->obmat);
823                 Mat3Inv(imat, bmat);
824
825                 curs= give_cursor();
826                 hmd->cent[0]= curs[0]-ob->obmat[3][0];
827                 hmd->cent[1]= curs[1]-ob->obmat[3][1];
828                 hmd->cent[2]= curs[2]-ob->obmat[3][2];
829                 Mat3MulVecfl(imat, hmd->cent);
830
831                 ED_undo_push(C, "Hook cursor center");
832         }*/
833 }
834
835 static void modifiers_selectHook(bContext *C, void *ob_v, void *md_v)
836 {
837         /* XXX ModifierData *md = md_v;
838         HookModifierData *hmd = (HookModifierData*) md;
839
840         hook_select(hmd);*/
841 }
842
843 static void modifiers_reassignHook(bContext *C, void *ob_v, void *md_v)
844 {
845         /* XXX ModifierData *md = md_v;
846         HookModifierData *hmd = (HookModifierData*) md;
847         float cent[3];
848         int *indexar, tot, ok;
849         char name[32];
850                 
851         ok= hook_getIndexArray(&tot, &indexar, name, cent);
852
853         if (!ok) {
854                 uiPupMenuError(C, "Requires selected vertices or active Vertex Group");
855         } else {
856                 if (hmd->indexar) {
857                         MEM_freeN(hmd->indexar);
858                 }
859
860                 VECCOPY(hmd->cent, cent);
861                 hmd->indexar = indexar;
862                 hmd->totindex = tot;
863         }*/
864 }
865
866 void modifiers_explodeFacepa(bContext *C, void *arg1, void *arg2)
867 {
868         ExplodeModifierData *emd=arg1;
869
870         emd->flag |= eExplodeFlag_CalcFaces;
871 }
872
873 void modifiers_explodeDelVg(bContext *C, void *arg1, void *arg2)
874 {
875         ExplodeModifierData *emd=arg1;
876         emd->vgroup = 0;
877 }
878 #endif
879
880