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