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