source/blender/editors/armature/editarmature_undo.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  15  *
  16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  17  * All rights reserved.
  18  */
  19
  20 /** \file
  21  * \ingroup edarmature
  22  */
  23
  24 #include "MEM_guardedalloc.h"
  25
  26 #include "CLG_log.h"
  27
  28 #include "DNA_armature_types.h"
  29 #include "DNA_object_types.h"
  30
  31 #include "BLI_array_utils.h"
  32 #include "BLI_listbase.h"
  33
  34 #include "BKE_context.h"
  35 #include "BKE_layer.h"
  36 #include "BKE_main.h"
  37 #include "BKE_undo_system.h"
  38
  39 #include "DEG_depsgraph.h"
  40
  41 #include "ED_armature.h"
  42 #include "ED_object.h"
  43 #include "ED_undo.h"
  44 #include "ED_util.h"
  45
  46 #include "WM_api.h"
  47 #include "WM_types.h"
  48
  49 /** We only need this locally. */
  50 static CLG_LogRef LOG = {"ed.undo.armature"};
  51
  52 /* -------------------------------------------------------------------- */
  53 /** \name Undo Conversion
  54  * \{ */
  55
  56 typedef struct UndoArmature {
  57   EditBone *act_edbone;
  58   ListBase lb;
  59   size_t undo_size;
  60 } UndoArmature;
  61
  62 static void undoarm_to_editarm(UndoArmature *uarm, bArmature *arm)
  63 {
  64   EditBone *ebone;
  65
  66   ED_armature_ebone_listbase_free(arm->edbo);
  67   ED_armature_ebone_listbase_copy(arm->edbo, &uarm->lb);
  68
  69   /* active bone */
  70   if (uarm->act_edbone) {
  71     ebone = uarm->act_edbone;
  72     arm->act_edbone = ebone->temp.ebone;
  73   }
  74   else {
  75     arm->act_edbone = NULL;
  76   }
  77
  78   ED_armature_ebone_listbase_temp_clear(arm->edbo);
  79 }
  80
  81 static void *undoarm_from_editarm(UndoArmature *uarm, bArmature *arm)
  82 {
  83   BLI_assert(BLI_array_is_zeroed(uarm, 1));
  84
  85   /* TODO: include size of ID-properties. */
  86   uarm->undo_size = 0;
  87
  88   ED_armature_ebone_listbase_copy(&uarm->lb, arm->edbo);
  89
  90   /* active bone */
  91   if (arm->act_edbone) {
  92     EditBone *ebone = arm->act_edbone;
  93     uarm->act_edbone = ebone->temp.ebone;
  94   }
  95
  96   ED_armature_ebone_listbase_temp_clear(&uarm->lb);
  97
  98   LISTBASE_FOREACH (EditBone *, ebone, &uarm->lb) {
  99     uarm->undo_size += sizeof(EditBone);
 100   }
 101
 102   return uarm;
 103 }
 104
 105 static void undoarm_free_data(UndoArmature *uarm)
 106 {
 107   ED_armature_ebone_listbase_free(&uarm->lb);
 108 }
 109
 110 static Object *editarm_object_from_context(bContext *C)
 111 {
 112   ViewLayer *view_layer = CTX_data_view_layer(C);
 113   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
 114   if (obedit && obedit->type == OB_ARMATURE) {
 115     bArmature *arm = obedit->data;
 116     if (arm->edbo != NULL) {
 117       return obedit;
 118     }
 119   }
 120   return NULL;
 121 }
 122
 123 /** \} */
 124
 125 /* -------------------------------------------------------------------- */
 126 /** \name Implements ED Undo System
 127  *
 128  * \note This is similar for all edit-mode types.
 129  * \{ */
 130
 131 typedef struct ArmatureUndoStep_Elem {
 132   struct ArmatureUndoStep_Elem *next, *prev;
 133   UndoRefID_Object obedit_ref;
 134   UndoArmature data;
 135 } ArmatureUndoStep_Elem;
 136
 137 typedef struct ArmatureUndoStep {
 138   UndoStep step;
 139   ArmatureUndoStep_Elem *elems;
 140   uint elems_len;
 141 } ArmatureUndoStep;
 142
 143 static bool armature_undosys_poll(bContext *C)
 144 {
 145   return editarm_object_from_context(C) != NULL;
 146 }
 147
 148 static bool armature_undosys_step_encode(struct bContext *C, struct Main *bmain, UndoStep *us_p)
 149 {
 150   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 151
 152   /* Important not to use the 3D view when getting objects because all objects
 153    * outside of this list will be moved out of edit-mode when reading back undo steps. */
 154   ViewLayer *view_layer = CTX_data_view_layer(C);
 155   uint objects_len = 0;
 156   Object **objects = ED_undo_editmode_objects_from_view_layer(view_layer, &objects_len);
 157
 158   us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
 159   us->elems_len = objects_len;
 160
 161   for (uint i = 0; i < objects_len; i++) {
 162     Object *ob = objects[i];
 163     ArmatureUndoStep_Elem *elem = &us->elems[i];
 164
 165     elem->obedit_ref.ptr = ob;
 166     bArmature *arm = elem->obedit_ref.ptr->data;
 167     undoarm_from_editarm(&elem->data, arm);
 168     arm->needs_flush_to_id = 1;
 169     us->step.data_size += elem->data.undo_size;
 170   }
 171   MEM_freeN(objects);
 172
 173   bmain->is_memfile_undo_flush_needed = true;
 174
 175   return true;
 176 }
 177
 178 static void armature_undosys_step_decode(
 179     struct bContext *C, struct Main *bmain, UndoStep *us_p, int UNUSED(dir), bool UNUSED(is_final))
 180 {
 181   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 182
 183   /* Load all our objects  into edit-mode, clear everything else. */
 184   ED_undo_object_editmode_restore_helper(
 185       C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
 186
 187   BLI_assert(armature_undosys_poll(C));
 188
 189   for (uint i = 0; i < us->elems_len; i++) {
 190     ArmatureUndoStep_Elem *elem = &us->elems[i];
 191     Object *obedit = elem->obedit_ref.ptr;
 192     bArmature *arm = obedit->data;
 193     if (arm->edbo == NULL) {
 194       /* Should never fail, may not crash but can give odd behavior. */
 195       CLOG_ERROR(&LOG,
 196                  "name='%s', failed to enter edit-mode for object '%s', undo state invalid",
 197                  us_p->name,
 198                  obedit->id.name);
 199       continue;
 200     }
 201     undoarm_to_editarm(&elem->data, arm);
 202     arm->needs_flush_to_id = 1;
 203     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
 204   }
 205
 206   /* The first element is always active */
 207   ED_undo_object_set_active_or_warn(
 208       CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
 209
 210   bmain->is_memfile_undo_flush_needed = true;
 211
 212   WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
 213 }
 214
 215 static void armature_undosys_step_free(UndoStep *us_p)
 216 {
 217   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 218
 219   for (uint i = 0; i < us->elems_len; i++) {
 220     ArmatureUndoStep_Elem *elem = &us->elems[i];
 221     undoarm_free_data(&elem->data);
 222   }
 223   MEM_freeN(us->elems);
 224 }
 225
 226 static void armature_undosys_foreach_ID_ref(UndoStep *us_p,
 227                                             UndoTypeForEachIDRefFn foreach_ID_ref_fn,
 228                                             void *user_data)
 229 {
 230   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 231
 232   for (uint i = 0; i < us->elems_len; i++) {
 233     ArmatureUndoStep_Elem *elem = &us->elems[i];
 234     foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
 235   }
 236 }
 237
 238 /* Export for ED_undo_sys. */
 239 void ED_armature_undosys_type(UndoType *ut)
 240 {
 241   ut->name = "Edit Armature";
 242   ut->poll = armature_undosys_poll;
 243   ut->step_encode = armature_undosys_step_encode;
 244   ut->step_decode = armature_undosys_step_decode;
 245   ut->step_free = armature_undosys_step_free;
 246
 247   ut->step_foreach_ID_ref = armature_undosys_foreach_ID_ref;
 248
 249   ut->use_context = true;
 250
 251   ut->step_size = sizeof(ArmatureUndoStep);
 252 }
 253
 254 /** \} */