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 \ingroup edarmature
  21  */
  22
  23 #include "MEM_guardedalloc.h"
  24
  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
  33 #include "BKE_context.h"
  34 #include "BKE_layer.h"
  35 #include "BKE_undo_system.h"
  36
  37 #include "DEG_depsgraph.h"
  38
  39 #include "ED_armature.h"
  40 #include "ED_object.h"
  41 #include "ED_undo.h"
  42 #include "ED_util.h"
  43
  44 #include "WM_types.h"
  45 #include "WM_api.h"
  46
  47 /** We only need this locally. */
  48 static CLG_LogRef LOG = {"ed.undo.armature"};
  49
  50 /* -------------------------------------------------------------------- */
  51 /** \name Undo Conversion
  52  * \{ */
  53
  54 typedef struct UndoArmature {
  55         EditBone *act_edbone;
  56         ListBase lb;
  57         size_t undo_size;
  58 } UndoArmature;
  59
  60 static void undoarm_to_editarm(UndoArmature *uarm, bArmature *arm)
  61 {
  62         EditBone *ebone;
  63
  64         ED_armature_ebone_listbase_free(arm->edbo);
  65         ED_armature_ebone_listbase_copy(arm->edbo, &uarm->lb);
  66
  67         /* active bone */
  68         if (uarm->act_edbone) {
  69                 ebone = uarm->act_edbone;
  70                 arm->act_edbone = ebone->temp.ebone;
  71         }
  72         else {
  73                 arm->act_edbone = NULL;
  74         }
  75
  76         ED_armature_ebone_listbase_temp_clear(arm->edbo);
  77 }
  78
  79 static void *undoarm_from_editarm(UndoArmature *uarm, bArmature *arm)
  80 {
  81         BLI_assert(BLI_array_is_zeroed(uarm, 1));
  82
  83         /* TODO: include size of ID-properties. */
  84         uarm->undo_size = 0;
  85
  86         ED_armature_ebone_listbase_copy(&uarm->lb, arm->edbo);
  87
  88         /* active bone */
  89         if (arm->act_edbone) {
  90                 EditBone *ebone = arm->act_edbone;
  91                 uarm->act_edbone = ebone->temp.ebone;
  92         }
  93
  94         ED_armature_ebone_listbase_temp_clear(&uarm->lb);
  95
  96         for (EditBone *ebone = uarm->lb.first; ebone; ebone = ebone->next) {
  97                 uarm->undo_size += sizeof(EditBone);
  98         }
  99
 100         return uarm;
 101 }
 102
 103 static void undoarm_free_data(UndoArmature *uarm)
 104 {
 105         ED_armature_ebone_listbase_free(&uarm->lb);
 106 }
 107
 108 static Object *editarm_object_from_context(bContext *C)
 109 {
 110         Object *obedit = CTX_data_edit_object(C);
 111         if (obedit && obedit->type == OB_ARMATURE) {
 112                 bArmature *arm = obedit->data;
 113                 if (arm->edbo != NULL) {
 114                         return obedit;
 115                 }
 116         }
 117         return NULL;
 118 }
 119
 120 /** \} */
 121
 122 /* -------------------------------------------------------------------- */
 123 /** \name Implements ED Undo System
 124  *
 125  * \note This is similar for all edit-mode types.
 126  * \{ */
 127
 128 typedef struct ArmatureUndoStep_Elem {
 129         struct ArmatureUndoStep_Elem *next, *prev;
 130         UndoRefID_Object obedit_ref;
 131         UndoArmature data;
 132 } ArmatureUndoStep_Elem;
 133
 134 typedef struct ArmatureUndoStep {
 135         UndoStep step;
 136         ArmatureUndoStep_Elem *elems;
 137         uint                   elems_len;
 138 } ArmatureUndoStep;
 139
 140 static bool armature_undosys_poll(bContext *C)
 141 {
 142         return editarm_object_from_context(C) != NULL;
 143 }
 144
 145 static bool armature_undosys_step_encode(struct bContext *C, struct Main *UNUSED(bmain), UndoStep *us_p)
 146 {
 147         ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 148
 149         /* Important not to use the 3D view when getting objects because all objects
 150          * outside of this list will be moved out of edit-mode when reading back undo steps. */
 151         ViewLayer *view_layer = CTX_data_view_layer(C);
 152         uint objects_len = 0;
 153         Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, NULL, &objects_len);
 154
 155         us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
 156         us->elems_len = objects_len;
 157
 158         for (uint i = 0; i < objects_len; i++) {
 159                 Object *ob = objects[i];
 160                 ArmatureUndoStep_Elem *elem = &us->elems[i];
 161
 162                 elem->obedit_ref.ptr = ob;
 163                 bArmature *arm = elem->obedit_ref.ptr->data;
 164                 undoarm_from_editarm(&elem->data, arm);
 165                 us->step.data_size += elem->data.undo_size;
 166         }
 167         MEM_freeN(objects);
 168         return true;
 169 }
 170
 171 static void armature_undosys_step_decode(struct bContext *C, struct Main *UNUSED(bmain), UndoStep *us_p, int UNUSED(dir))
 172 {
 173         ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 174
 175         /* Load all our objects  into edit-mode, clear everything else. */
 176         ED_undo_object_editmode_restore_helper(C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
 177
 178         BLI_assert(armature_undosys_poll(C));
 179
 180         for (uint i = 0; i < us->elems_len; i++) {
 181                 ArmatureUndoStep_Elem *elem = &us->elems[i];
 182                 Object *obedit = elem->obedit_ref.ptr;
 183                 bArmature *arm = obedit->data;
 184                 if (arm->edbo == NULL) {
 185                         /* Should never fail, may not crash but can give odd behavior. */
 186                         CLOG_ERROR(&LOG, "name='%s', failed to enter edit-mode for object '%s', undo state invalid", us_p->name, obedit->id.name);
 187                         continue;
 188                 }
 189                 undoarm_to_editarm(&elem->data, arm);
 190                 DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
 191         }
 192
 193         /* The first element is always active */
 194         ED_undo_object_set_active_or_warn(CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
 195
 196         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
 197 }
 198
 199 static void armature_undosys_step_free(UndoStep *us_p)
 200 {
 201         ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 202
 203         for (uint i = 0; i < us->elems_len; i++) {
 204                 ArmatureUndoStep_Elem *elem = &us->elems[i];
 205                 undoarm_free_data(&elem->data);
 206         }
 207         MEM_freeN(us->elems);
 208 }
 209
 210 static void armature_undosys_foreach_ID_ref(
 211         UndoStep *us_p, UndoTypeForEachIDRefFn foreach_ID_ref_fn, void *user_data)
 212 {
 213         ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
 214
 215         for (uint i = 0; i < us->elems_len; i++) {
 216                 ArmatureUndoStep_Elem *elem = &us->elems[i];
 217                 foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
 218         }
 219 }
 220
 221 /* Export for ED_undo_sys. */
 222 void ED_armature_undosys_type(UndoType *ut)
 223 {
 224         ut->name = "Edit Armature";
 225         ut->poll = armature_undosys_poll;
 226         ut->step_encode = armature_undosys_step_encode;
 227         ut->step_decode = armature_undosys_step_decode;
 228         ut->step_free = armature_undosys_step_free;
 229
 230         ut->step_foreach_ID_ref = armature_undosys_foreach_ID_ref;
 231
 232         ut->use_context = true;
 233
 234         ut->step_size = sizeof(ArmatureUndoStep);
 235 }
 236
 237 /** \} */