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, mat, 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