Hook Modifier Bugfixes:
[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_action_types.h"
35 #include "DNA_curve_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_modifier_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_object_force.h"
41 #include "DNA_scene_types.h"
42
43 #include "BLI_arithb.h"
44 #include "BLI_listbase.h"
45
46 #include "BKE_action.h"
47 #include "BKE_curve.h"
48 #include "BKE_context.h"
49 #include "BKE_depsgraph.h"
50 #include "BKE_displist.h"
51 #include "BKE_DerivedMesh.h"
52 #include "BKE_effect.h"
53 #include "BKE_global.h"
54 #include "BKE_lattice.h"
55 #include "BKE_mesh.h"
56 #include "BKE_modifier.h"
57 #include "BKE_multires.h"
58 #include "BKE_report.h"
59 #include "BKE_object.h"
60 #include "BKE_particle.h"
61 #include "BKE_softbody.h"
62 #include "BKE_utildefines.h"
63
64 #include "RNA_access.h"
65 #include "RNA_define.h"
66 #include "RNA_enum_types.h"
67
68 #include "ED_screen.h"
69
70 #include "WM_api.h"
71 #include "WM_types.h"
72
73 #include "object_intern.h"
74
75 /******************************** API ****************************/
76
77 int ED_object_modifier_add(ReportList *reports, Scene *scene, Object *ob, int type)
78 {
79         ModifierData *md;
80         ModifierTypeInfo *mti = modifierType_getInfo(type);
81
82         if(mti->flags&eModifierTypeFlag_Single) {
83                 if(modifiers_findByType(ob, type)) {
84                         BKE_report(reports, RPT_WARNING, "Only one modifier of this type allowed.");
85                         return 0;
86                 }
87         }
88
89         if(type == eModifierType_ParticleSystem) {
90                 object_add_particle_system(scene, ob);
91         }
92         else {
93                 if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
94                         md = ob->modifiers.first;
95
96                         while(md && modifierType_getInfo(md->type)->type==eModifierTypeType_OnlyDeform)
97                                 md = md->next;
98
99                         BLI_insertlinkbefore(&ob->modifiers, md, modifier_new(type));
100                 }
101                 else
102                         BLI_addtail(&ob->modifiers, modifier_new(type));
103                 
104                 /* special cases */
105                 if(type == eModifierType_Softbody) {
106                         if(!ob->soft) {
107                                 ob->soft= sbNew(scene);
108                                 ob->softflag |= OB_SB_GOAL|OB_SB_EDGES;
109                         }
110                 }
111                 else if(type == eModifierType_Collision) {
112                         if(!ob->pd)
113                                 ob->pd= object_add_collision_fields();
114
115                         ob->pd->deflect= 1;
116                         DAG_scene_sort(scene);
117                 }
118                 else if(type == eModifierType_Surface)
119                         DAG_scene_sort(scene);
120         }
121
122         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
123
124         return 1;
125 }
126
127 int ED_object_modifier_remove(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
128 {
129         ModifierData *obmd;
130
131         /* It seems on rapid delete it is possible to
132          * get called twice on same modifier, so make
133          * sure it is in list. */
134         for(obmd=ob->modifiers.first; obmd; obmd=obmd->next)
135                 if(obmd==md)
136                         break;
137         
138         if(!obmd)
139                 return 0;
140
141         /* special cases */
142         if(md->type == eModifierType_ParticleSystem) {
143                 ParticleSystemModifierData *psmd=(ParticleSystemModifierData*)md;
144
145                 BLI_remlink(&ob->particlesystem, psmd->psys);
146                 psys_free(ob, psmd->psys);
147         }
148         else if(md->type == eModifierType_Softbody) {
149                 if(ob->soft) {
150                         sbFree(ob->soft);
151                         ob->soft= NULL;
152                         ob->softflag= 0;
153                 }
154         }
155         else if(md->type == eModifierType_Collision) {
156                 if(ob->pd)
157                         ob->pd->deflect= 0;
158
159         DAG_scene_sort(scene);
160         }
161         else if(md->type == eModifierType_Surface) {
162                 if(ob->pd)
163                         ob->pd->flag &= ~PFIELD_SURFACE;
164
165         DAG_scene_sort(scene);
166         }
167         else if(md->type == eModifierType_Smoke) {
168                 ModifierData *tmd = modifiers_findByType(ob, eModifierType_SmokeHR);
169                 if(tmd) {
170                         BLI_remlink(&ob->modifiers, tmd);
171                         modifier_free(tmd);
172                 }
173         }
174
175         BLI_remlink(&ob->modifiers, md);
176         modifier_free(md);
177
178         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
179
180         return 1;
181 }
182
183 int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
184 {
185         if(md->prev) {
186                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
187
188                 if(mti->type!=eModifierTypeType_OnlyDeform) {
189                         ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);
190
191                         if(nmti->flags&eModifierTypeFlag_RequiresOriginalData) {
192                                 BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data.");
193                                 return 0;
194                         }
195                 }
196
197                 BLI_remlink(&ob->modifiers, md);
198                 BLI_insertlink(&ob->modifiers, md->prev->prev, md);
199         }
200
201         return 1;
202 }
203
204 int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
205 {
206         if(md->next) {
207                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
208
209                 if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {
210                         ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);
211
212                         if(nmti->type!=eModifierTypeType_OnlyDeform) {
213                                 BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier.");
214                                 return 0;
215                         }
216                 }
217
218                 BLI_remlink(&ob->modifiers, md);
219                 BLI_insertlink(&ob->modifiers, md->next, md);
220         }
221
222         return 1;
223 }
224
225 int ED_object_modifier_convert(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
226 {
227         Object *obn;
228         ParticleSystem *psys;
229         ParticleCacheKey *key, **cache;
230         ParticleSettings *part;
231         Mesh *me;
232         MVert *mvert;
233         MEdge *medge;
234         int a, k, kmax;
235         int totvert=0, totedge=0, cvert=0;
236         int totpart=0, totchild=0;
237
238         if(md->type != eModifierType_ParticleSystem) return 0;
239         if(ob && ob->mode & OB_MODE_PARTICLE_EDIT) return 0;
240
241         psys=((ParticleSystemModifierData *)md)->psys;
242         part= psys->part;
243
244         if(part->ren_as == PART_DRAW_GR || part->ren_as == PART_DRAW_OB) {
245                 ; // XXX make_object_duplilist_real(NULL);
246         }
247         else {
248                 if(part->ren_as != PART_DRAW_PATH || psys->pathcache == 0)
249                         return 0;
250
251                 totpart= psys->totcached;
252                 totchild= psys->totchildcache;
253
254                 if(totchild && (part->draw&PART_DRAW_PARENT)==0)
255                         totpart= 0;
256
257                 /* count */
258                 cache= psys->pathcache;
259                 for(a=0; a<totpart; a++) {
260                         key= cache[a];
261                         totvert+= key->steps+1;
262                         totedge+= key->steps;
263                 }
264
265                 cache= psys->childcache;
266                 for(a=0; a<totchild; a++) {
267                         key= cache[a];
268                         totvert+= key->steps+1;
269                         totedge+= key->steps;
270                 }
271
272                 if(totvert==0) return 0;
273
274                 /* add new mesh */
275                 obn= add_object(scene, OB_MESH);
276                 me= obn->data;
277                 
278                 me->totvert= totvert;
279                 me->totedge= totedge;
280                 
281                 me->mvert= CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
282                 me->medge= CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
283                 me->mface= CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
284                 
285                 mvert= me->mvert;
286                 medge= me->medge;
287
288                 /* copy coordinates */
289                 cache= psys->pathcache;
290                 for(a=0; a<totpart; 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                 cache=psys->childcache;
305                 for(a=0; a<totchild; a++) {
306                         key=cache[a];
307                         kmax=key->steps;
308                         for(k=0; k<=kmax; k++,key++,cvert++,mvert++) {
309                                 VECCOPY(mvert->co,key->co);
310                                 if(k) {
311                                         medge->v1=cvert-1;
312                                         medge->v2=cvert;
313                                         medge->flag= ME_EDGEDRAW|ME_EDGERENDER|ME_LOOSEEDGE;
314                                         medge++;
315                                 }
316                         }
317                 }
318         }
319
320         DAG_scene_sort(scene);
321
322         return 1;
323 }
324
325 int ED_object_modifier_apply(ReportList *reports, Scene *scene, Object *ob, ModifierData *md)
326 {
327         DerivedMesh *dm;
328         Mesh *me = ob->data;
329         int converted = 0;
330
331         if (scene->obedit) {
332                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied in editmode");
333                 return 0;
334         } else if (((ID*) ob->data)->us>1) {
335                 BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied to multi-user data");
336                 return 0;
337         }
338
339         if (md!=ob->modifiers.first)
340                 BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected.");
341
342         if (ob->type==OB_MESH) {
343                 if(me->key) {
344                         BKE_report(reports, RPT_ERROR, "Modifier cannot be applied to Mesh with Shape Keys");
345                         return 0;
346                 }
347         
348                 mesh_pmv_off(ob, me);
349
350                /* Multires: ensure that recent sculpting is applied */
351                if(md->type == eModifierType_Multires)
352                        multires_force_update(ob);
353         
354                 dm = mesh_create_derived_for_modifier(scene, ob, md);
355                 if (!dm) {
356                         BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
357                         return 0;
358                 }
359
360                 DM_to_mesh(dm, me);
361                 converted = 1;
362
363                 dm->release(dm);
364         } 
365         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
366                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
367                 Curve *cu = ob->data;
368                 int numVerts;
369                 float (*vertexCos)[3];
370
371                 BKE_report(reports, RPT_INFO, "Applied modifier only changed CV points, not tesselated/bevel vertices");
372
373                 if (!(md->mode&eModifierMode_Realtime) || (mti->isDisabled && mti->isDisabled(md))) {
374                         BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
375                         return 0;
376                 }
377
378                 vertexCos = curve_getVertexCos(cu, &cu->nurb, &numVerts);
379                 mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0, 0);
380                 curve_applyVertexCos(cu, &cu->nurb, vertexCos);
381
382                 converted = 1;
383
384                 MEM_freeN(vertexCos);
385
386                 DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
387         }
388         else {
389                 BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
390                 return 0;
391         }
392
393         if (converted) {
394                 BLI_remlink(&ob->modifiers, md);
395                 modifier_free(md);
396
397                 return 1;
398         }
399
400         return 0;
401 }
402
403 int ED_object_modifier_copy(ReportList *reports, Object *ob, ModifierData *md)
404 {
405         ModifierData *nmd;
406         
407         nmd = modifier_new(md->type);
408         modifier_copyData(md, nmd);
409         BLI_insertlink(&ob->modifiers, md, nmd);
410
411         return 1;
412 }
413
414 /***************************** OPERATORS ****************************/
415
416 static int modifier_poll(bContext *C)
417 {
418         return (CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier).data != NULL);
419 }
420
421 /************************ add modifier operator *********************/
422
423 static int modifier_add_exec(bContext *C, wmOperator *op)
424 {
425         Scene *scene= CTX_data_scene(C);
426     Object *ob = CTX_data_active_object(C);
427         int type= RNA_enum_get(op->ptr, "type");
428
429         if(!ED_object_modifier_add(op->reports, scene, ob, type))
430                 return OPERATOR_CANCELLED;
431
432         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
433         
434         return OPERATOR_FINISHED;
435 }
436
437 static EnumPropertyItem *modifier_add_itemf(bContext *C, PointerRNA *ptr, int *free)
438 {       
439         EnumPropertyItem *item= NULL, *md_item;
440         ModifierTypeInfo *mti;
441         Object *ob;
442         int totitem= 0, a;
443         
444         if(!C) /* needed for docs */
445                 return modifier_type_items;
446         
447         ob= CTX_data_active_object(C);
448
449         for(a=0; modifier_type_items[a].identifier; a++) {
450                 md_item= &modifier_type_items[a];
451
452                 if(md_item->identifier[0]) {
453                         mti= modifierType_getInfo(md_item->value);
454
455                         if(mti->flags & eModifierTypeFlag_NoUserAdd)
456                                 continue;
457
458                         if(!((mti->flags & eModifierTypeFlag_AcceptsCVs) ||
459                            (ob->type==OB_MESH && (mti->flags & eModifierTypeFlag_AcceptsMesh))))
460                                 continue;
461                 }
462
463                 RNA_enum_item_add(&item, &totitem, md_item);
464         }
465
466         RNA_enum_item_end(&item, &totitem);
467
468         *free= 1;
469
470         return item;
471 }
472
473 void OBJECT_OT_modifier_add(wmOperatorType *ot)
474 {
475         PropertyRNA *prop;
476
477         /* identifiers */
478         ot->name= "Add Modifier";
479         ot->description = "Add a modifier to the active object.";
480         ot->idname= "OBJECT_OT_modifier_add";
481         
482         /* api callbacks */
483         ot->invoke= WM_menu_invoke;
484         ot->exec= modifier_add_exec;
485         ot->poll= ED_operator_object_active;
486         
487         /* flags */
488         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
489         
490         /* properties */
491         prop= RNA_def_enum(ot->srna, "type", modifier_type_items, eModifierType_Subsurf, "Type", "");
492         RNA_def_enum_funcs(prop, modifier_add_itemf);
493 }
494
495 /************************ remove modifier operator *********************/
496
497 static int modifier_remove_exec(bContext *C, wmOperator *op)
498 {
499         Scene *scene= CTX_data_scene(C);
500         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
501         Object *ob= ptr.id.data;
502         ModifierData *md= ptr.data;
503
504         if(!ED_object_modifier_remove(op->reports, scene, ob, md))
505                 return OPERATOR_CANCELLED;
506
507         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
508         
509         return OPERATOR_FINISHED;
510 }
511
512 void OBJECT_OT_modifier_remove(wmOperatorType *ot)
513 {
514         ot->name= "Remove Modifier";
515         ot->description= "Remove a modifier from the active object.";
516         ot->idname= "OBJECT_OT_modifier_remove";
517         ot->poll= ED_operator_object_active;
518
519         ot->exec= modifier_remove_exec;
520         ot->poll= modifier_poll;
521         
522         /* flags */
523         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
524 }
525
526 /************************ move up modifier operator *********************/
527
528 static int modifier_move_up_exec(bContext *C, wmOperator *op)
529 {
530         Scene *scene= CTX_data_scene(C);
531         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
532         Object *ob= ptr.id.data;
533         ModifierData *md= ptr.data;
534
535         if(!ED_object_modifier_move_up(op->reports, ob, md))
536                 return OPERATOR_CANCELLED;
537
538         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
539         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
540         
541         return OPERATOR_FINISHED;
542 }
543
544 void OBJECT_OT_modifier_move_up(wmOperatorType *ot)
545 {
546         ot->name= "Move Up Modifier";
547         ot->description= "Move modifier up in the stack.";
548         ot->idname= "OBJECT_OT_modifier_move_up";
549         ot->poll= ED_operator_object_active;
550
551         ot->exec= modifier_move_up_exec;
552         ot->poll= modifier_poll;
553         
554         /* flags */
555         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
556 }
557
558 /************************ move down modifier operator *********************/
559
560 static int modifier_move_down_exec(bContext *C, wmOperator *op)
561 {
562         Scene *scene= CTX_data_scene(C);
563         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
564         Object *ob= ptr.id.data;
565         ModifierData *md= ptr.data;
566
567         if(!ob || !md || !ED_object_modifier_move_down(op->reports, ob, md))
568                 return OPERATOR_CANCELLED;
569
570         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
571         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
572         
573         return OPERATOR_FINISHED;
574 }
575
576 void OBJECT_OT_modifier_move_down(wmOperatorType *ot)
577 {
578         ot->name= "Move Down Modifier";
579         ot->description= "Move modifier down in the stack.";
580         ot->idname= "OBJECT_OT_modifier_move_down";
581         ot->poll= ED_operator_object_active;
582
583         ot->exec= modifier_move_down_exec;
584         ot->poll= modifier_poll;
585         
586         /* flags */
587         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
588 }
589
590 /************************ apply modifier operator *********************/
591
592 static int modifier_apply_exec(bContext *C, wmOperator *op)
593 {
594         Scene *scene= CTX_data_scene(C);
595         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
596         Object *ob= ptr.id.data;
597         ModifierData *md= ptr.data;
598
599         if(!ob || !md || !ED_object_modifier_apply(op->reports, scene, ob, md))
600                 return OPERATOR_CANCELLED;
601
602         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
603         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
604         
605         return OPERATOR_FINISHED;
606 }
607
608 void OBJECT_OT_modifier_apply(wmOperatorType *ot)
609 {
610         ot->name= "Apply Modifier";
611         ot->description= "Apply modifier and remove from the stack.";
612         ot->idname= "OBJECT_OT_modifier_apply";
613         ot->poll= ED_operator_object_active;
614
615         ot->exec= modifier_apply_exec;
616         ot->poll= modifier_poll;
617         
618         /* flags */
619         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
620 }
621
622 /************************ convert modifier operator *********************/
623
624 static int modifier_convert_exec(bContext *C, wmOperator *op)
625 {
626         Scene *scene= CTX_data_scene(C);
627         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
628         Object *ob= ptr.id.data;
629         ModifierData *md= ptr.data;
630
631         if(!ob || !md || !ED_object_modifier_convert(op->reports, scene, ob, md))
632                 return OPERATOR_CANCELLED;
633
634         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
635         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
636         
637         return OPERATOR_FINISHED;
638 }
639
640 void OBJECT_OT_modifier_convert(wmOperatorType *ot)
641 {
642         ot->name= "Convert Modifier";
643         ot->description= "Convert particles to a mesh object.";
644         ot->idname= "OBJECT_OT_modifier_convert";
645         ot->poll= ED_operator_object_active;
646
647         ot->exec= modifier_convert_exec;
648         ot->poll= modifier_poll;
649         
650         /* flags */
651         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
652 }
653
654 /************************ copy modifier operator *********************/
655
656 static int modifier_copy_exec(bContext *C, wmOperator *op)
657 {
658         Scene *scene= CTX_data_scene(C);
659         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
660         Object *ob= ptr.id.data;
661         ModifierData *md= ptr.data;
662
663         if(!ob || !md || !ED_object_modifier_copy(op->reports, ob, md))
664                 return OPERATOR_CANCELLED;
665
666         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
667         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
668         
669         return OPERATOR_FINISHED;
670 }
671
672 void OBJECT_OT_modifier_copy(wmOperatorType *ot)
673 {
674         ot->name= "Copy Modifier";
675         ot->description= "Duplicate modifier at the same position in the stack.";
676         ot->idname= "OBJECT_OT_modifier_copy";
677         ot->poll= ED_operator_object_active;
678
679         ot->exec= modifier_copy_exec;
680         ot->poll= modifier_poll;
681         
682         /* flags */
683         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
684 }
685
686 /****************** multires subdivide operator *********************/
687
688 static int multires_subdivide_exec(bContext *C, wmOperator *op)
689 {
690         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_MultiresModifier);
691         Object *ob= ptr.id.data;
692         MultiresModifierData *mmd= ptr.data;
693
694         multiresModifier_subdivide(mmd, ob, 1, 0, mmd->simple);
695         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
696         
697         return OPERATOR_FINISHED;
698 }
699
700 static int multires_subdivide_poll(bContext *C)
701 {
702         return (CTX_data_pointer_get_type(C, "modifier", &RNA_MultiresModifier).data != NULL) &&
703                 CTX_data_edit_object(C) == NULL;
704 }
705
706 void OBJECT_OT_multires_subdivide(wmOperatorType *ot)
707 {
708         ot->name= "Multires Subdivide";
709         ot->description= "Add a new level of subdivision.";
710         ot->idname= "OBJECT_OT_multires_subdivide";
711
712         ot->exec= multires_subdivide_exec;
713         ot->poll= multires_subdivide_poll;
714         
715         /* flags */
716         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
717 }
718
719 /************************ mdef bind operator *********************/
720
721 static int meshdeform_poll(bContext *C)
722 {
723         return CTX_data_pointer_get_type(C, "modifier", &RNA_MeshDeformModifier).data != NULL;
724 }
725
726 static int meshdeform_bind_exec(bContext *C, wmOperator *op)
727 {
728         Scene *scene= CTX_data_scene(C);
729         PointerRNA ptr= CTX_data_pointer_get(C, "modifier");
730         Object *ob= ptr.id.data;
731         MeshDeformModifierData *mmd= ptr.data;
732
733         if(mmd->bindcos) {
734                 if(mmd->bindweights) MEM_freeN(mmd->bindweights);
735                 if(mmd->bindcos) MEM_freeN(mmd->bindcos);
736                 if(mmd->dyngrid) MEM_freeN(mmd->dyngrid);
737                 if(mmd->dyninfluences) MEM_freeN(mmd->dyninfluences);
738                 if(mmd->dynverts) MEM_freeN(mmd->dynverts);
739                 mmd->bindweights= NULL;
740                 mmd->bindcos= NULL;
741                 mmd->dyngrid= NULL;
742                 mmd->dyninfluences= NULL;
743                 mmd->dynverts= NULL;
744                 mmd->totvert= 0;
745                 mmd->totcagevert= 0;
746                 mmd->totinfluence= 0;
747         }
748         else {
749                 DerivedMesh *dm;
750                 int mode= mmd->modifier.mode;
751
752                 /* force modifier to run, it will call binding routine */
753                 mmd->needbind= 1;
754                 mmd->modifier.mode |= eModifierMode_Realtime;
755
756                 if(ob->type == OB_MESH) {
757                         dm= mesh_create_derived_view(scene, ob, 0);
758                         dm->release(dm);
759                 }
760                 else if(ob->type == OB_LATTICE) {
761                         lattice_calc_modifiers(scene, ob);
762                 }
763                 else if(ob->type==OB_MBALL) {
764                         makeDispListMBall(scene, ob);
765                 }
766                 else if(ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
767                         makeDispListCurveTypes(scene, ob, 0);
768                 }
769
770                 mmd->needbind= 0;
771                 mmd->modifier.mode= mode;
772         }
773         
774         return OPERATOR_FINISHED;
775 }
776
777 void OBJECT_OT_meshdeform_bind(wmOperatorType *ot)
778 {
779         /* identifiers */
780         ot->name= "Mesh Deform Bind";
781         ot->description = "Bind mesh to cage in mesh deform modifier.";
782         ot->idname= "OBJECT_OT_meshdeform_bind";
783         
784         /* api callbacks */
785         ot->poll= meshdeform_poll;
786         ot->exec= meshdeform_bind_exec;
787         
788         /* flags */
789         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
790 }
791
792 #if 0
793 typedef struct MenuEntry {
794         char *name;
795         int ID;
796 } MenuEntry;
797
798 static int menuEntry_compare_names(const void *entry1, const void *entry2)
799 {
800         return strcmp(((MenuEntry *)entry1)->name, ((MenuEntry *)entry2)->name);
801 }
802
803 static uiBlock *modifiers_add_menu(void *ob_v)
804 {
805         Object *ob = ob_v;
806         uiBlock *block;
807         int i, yco=0;
808         int numEntries = 0;
809         MenuEntry entries[NUM_MODIFIER_TYPES];
810         
811         block= uiNewBlock(&curarea->uiblocks, "modifier_add_menu",
812                           UI_EMBOSSP, UI_HELV, curarea->win);
813         uiBlockSetButmFunc(block, modifiers_add, ob);
814
815         for (i=eModifierType_None+1; i<NUM_MODIFIER_TYPES; i++) {
816                 ModifierTypeInfo *mti = modifierType_getInfo(i);
817
818                 /* Only allow adding through appropriate other interfaces */
819                 if(ELEM(i, eModifierType_ParticleSystem, eModifierType_Surface)) continue;
820
821                 if((mti->flags&eModifierTypeFlag_AcceptsCVs) ||
822                    (ob->type==OB_MESH && (mti->flags&eModifierTypeFlag_AcceptsMesh))) {
823                         entries[numEntries].name = mti->name;
824                         entries[numEntries].ID = i;
825
826                         ++numEntries;
827                 }
828         }
829
830         qsort(entries, numEntries, sizeof(*entries), menuEntry_compare_names);
831
832
833         for(i = 0; i < numEntries; ++i)
834                 uiDefBut(block, BUTM, B_MODIFIER_RECALC, entries[i].name,
835                          0, yco -= 20, 160, 19, NULL, 0, 0, 1, entries[i].ID, "");
836
837         uiTextBoundsBlock(block, 50);
838         uiBlockSetDirection(block, UI_DOWN);
839
840         return block;
841 }
842 #endif
843
844 /******************** hook operators ************************/
845
846 static int hook_poll(bContext *C)
847 {
848         return CTX_data_pointer_get_type(C, "modifier", &RNA_HookModifier).data != NULL;
849 }
850
851 static int hook_reset_exec(bContext *C, wmOperator *op)
852 {
853         Scene *scene= CTX_data_scene(C);
854         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_HookModifier);
855         Object *ob= ptr.id.data;
856         HookModifierData *hmd= ptr.data;
857
858         if(hmd->object) {
859                 bPoseChannel *pchan= get_pose_channel(hmd->object->pose, hmd->subtarget);
860                 
861                 if(hmd->subtarget[0] && pchan) {
862                         float imat[4][4], mat[4][4];
863                         
864                         /* calculate the world-space matrix for the pose-channel target first, then carry on as usual */
865                         Mat4MulMat4(mat, pchan->pose_mat, hmd->object->obmat);
866                         
867                         Mat4Invert(imat, mat);
868                         Mat4MulSerie(hmd->parentinv, imat, ob->obmat, NULL, NULL, NULL, NULL, NULL, NULL);
869                 }
870                 else {
871                         Mat4Invert(hmd->object->imat, hmd->object->obmat);
872                         Mat4MulSerie(hmd->parentinv, hmd->object->imat, ob->obmat, NULL, NULL, NULL, NULL, NULL, NULL);
873                 }
874         }
875
876         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
877         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
878         
879         return OPERATOR_FINISHED;
880 }
881
882 void OBJECT_OT_hook_reset(wmOperatorType *ot)
883 {
884         ot->name= "Hook Reset";
885         ot->description= "Recalculate and and clear offset transformation.";
886         ot->idname= "OBJECT_OT_hook_reset";
887
888         ot->exec= hook_reset_exec;
889         ot->poll= hook_poll;
890         
891         /* flags */
892         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
893 }
894
895 static int hook_recenter_exec(bContext *C, wmOperator *op)
896 {
897         Scene *scene= CTX_data_scene(C);
898         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_HookModifier);
899         Object *ob= ptr.id.data;
900         HookModifierData *hmd= ptr.data;
901         float bmat[3][3], imat[3][3];
902
903         Mat3CpyMat4(bmat, ob->obmat);
904         Mat3Inv(imat, bmat);
905
906         VECSUB(hmd->cent, scene->cursor, ob->obmat[3]);
907         Mat3MulVecfl(imat, hmd->cent);
908
909         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
910         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
911         
912         return OPERATOR_FINISHED;
913 }
914
915 void OBJECT_OT_hook_recenter(wmOperatorType *ot)
916 {
917         ot->name= "Hook Recenter";
918         ot->description= "Set hook center to cursor position.";
919         ot->idname= "OBJECT_OT_hook_recenter";
920
921         ot->exec= hook_recenter_exec;
922         ot->poll= hook_poll;
923         
924         /* flags */
925         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
926 }
927
928 static int hook_select_exec(bContext *C, wmOperator *op)
929 {
930         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_HookModifier);
931         Object *ob= ptr.id.data;
932         HookModifierData *hmd= ptr.data;
933
934         object_hook_select(ob, hmd);
935
936         WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_SELECT, ob);
937         
938         return OPERATOR_FINISHED;
939 }
940
941 void OBJECT_OT_hook_select(wmOperatorType *ot)
942 {
943         ot->name= "Hook Select";
944         ot->description= "Selects effected vertices on mesh.";
945         ot->idname= "OBJECT_OT_hook_select";
946
947         ot->exec= hook_select_exec;
948         ot->poll= hook_poll;
949         
950         /* flags */
951         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
952 }
953
954 static int hook_assign_exec(bContext *C, wmOperator *op)
955 {
956         Scene *scene= CTX_data_scene(C);
957         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_HookModifier);
958         Object *ob= ptr.id.data;
959         HookModifierData *hmd= ptr.data;
960         float cent[3];
961         char name[32];
962         int *indexar, tot;
963                 
964         if(!object_hook_index_array(ob, &tot, &indexar, name, cent)) {
965                 BKE_report(op->reports, RPT_WARNING, "Requires selected vertices or active vertex group");
966                 return OPERATOR_CANCELLED;
967         }
968
969         if(hmd->indexar)
970                 MEM_freeN(hmd->indexar);
971
972         VECCOPY(hmd->cent, cent);
973         hmd->indexar= indexar;
974         hmd->totindex= tot;
975
976         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
977         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
978         
979         return OPERATOR_FINISHED;
980 }
981
982 void OBJECT_OT_hook_assign(wmOperatorType *ot)
983 {
984         ot->name= "Hook Assign";
985         ot->description= "Reassigns selected vertices to hook.";
986         ot->idname= "OBJECT_OT_hook_assign";
987
988         ot->exec= hook_assign_exec;
989         ot->poll= hook_poll;
990         
991         /* flags */
992         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
993 }
994
995 /****************** explode refresh operator *********************/
996
997 static int explode_refresh_poll(bContext *C)
998 {
999         return CTX_data_pointer_get_type(C, "modifier", &RNA_ExplodeModifier).data != NULL;
1000 }
1001
1002 static int explode_refresh_exec(bContext *C, wmOperator *op)
1003 {
1004         Scene *scene= CTX_data_scene(C);
1005         PointerRNA ptr= CTX_data_pointer_get_type(C, "modifier", &RNA_ExplodeModifier);
1006         Object *ob= ptr.id.data;
1007         ExplodeModifierData *emd= ptr.data;
1008
1009         emd->flag |= eExplodeFlag_CalcFaces;
1010
1011         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
1012         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
1013         
1014         return OPERATOR_FINISHED;
1015 }
1016
1017 void OBJECT_OT_explode_refresh(wmOperatorType *ot)
1018 {
1019         ot->name= "Explode Refresh";
1020         ot->description= "Refresh data in the Explode modifier.";
1021         ot->idname= "OBJECT_OT_explode_refresh";
1022
1023         ot->exec= explode_refresh_exec;
1024         ot->poll= explode_refresh_poll;
1025         
1026         /* flags */
1027         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1028 }
1029