tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity
tornavis/source/blender/editors/sculpt_paint/sculpt_undo.cc

2070 lines
62 KiB
C++
Raw Blame History

/* SPDX-FileCopyrightText: 2006 by Nicholas Bishop. All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0-or-later */
/** \file
* \ingroup edsculpt
* Implements the Sculpt Mode tools.
*
* Usage Guide
* ===========
*
* The sculpt undo system is a delta-based system. Each undo step stores
* the difference with the prior one.
*
* To use the sculpt undo system, you must call push_begin
* inside an operator exec or invoke callback (geometry_begin
* may be called if you wish to save a non-delta copy of the entire mesh).
* This will initialize the sculpt undo stack and set up an undo step.
*
* At the end of the operator you should call push_end.
*
* push_end and geometry_begin both take a
* #wmOperatorType as an argument. There are _ex versions that allow a custom
* name; try to avoid using them. These can break the redo panel since it requires
* the undo push have the same name as the calling operator.
*
* NOTE: Sculpt undo steps are not appended to the global undo stack until
* the operator finishes. We use BKE_undosys_step_push_init_with_type to build
* a tentative undo step with is appended later when the operator ends.
* Operators must have the OPTYPE_UNDO flag set for this to work properly.
*/
#include <cstddef>
#include "MEM_guardedalloc.h"
#include "BLI_array_utils.hh"
#include "BLI_listbase.h"
#include "BLI_string.h"
#include "BLI_threads.h"
#include "BLI_utildefines.h"
#include "DNA_key_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "BKE_attribute.hh"
#include "BKE_ccg.h"
#include "BKE_context.hh"
#include "BKE_customdata.hh"
#include "BKE_global.hh"
#include "BKE_key.hh"
#include "BKE_layer.hh"
#include "BKE_main.hh"
#include "BKE_mesh.hh"
#include "BKE_multires.hh"
#include "BKE_object.hh"
#include "BKE_paint.hh"
#include "BKE_scene.hh"
#include "BKE_subdiv_ccg.hh"
#include "BKE_subsurf.hh"
#include "BKE_undo_system.hh"
/* TODO(sergey): Ideally should be no direct call to such low level things. */
#include "BKE_subdiv_eval.hh"
#include "DEG_depsgraph.hh"
#include "WM_api.hh"
#include "WM_types.hh"
#include "ED_geometry.hh"
#include "ED_object.hh"
#include "ED_sculpt.hh"
#include "ED_undo.hh"
#include "bmesh.hh"
#include "paint_intern.hh"
#include "sculpt_intern.hh"
namespace blender::ed::sculpt_paint::undo {
/* Uncomment to print the undo stack in the console on push/undo/redo. */
// #define SCULPT_UNDO_DEBUG
/* Implementation of undo system for objects in sculpt mode.
*
* Each undo step in sculpt mode consists of list of nodes, each node contains:
* - Node type
* - Data for this type.
*
* Node type used for undo depends on specific operation and active sculpt mode
* ("regular" or dynamic topology).
*
* Regular sculpt brushes will use COORDS, HIDDEN or MASK nodes. These nodes are
* created for every BVH node which is affected by the brush. The undo push for
* the node happens BEFORE modifications. This makes the operation undo to work
* in the following way: for every node in the undo step swap happens between
* node in the undo stack and the corresponding value in the BVH. This is how
* redo is possible after undo.
*
* The COORDS, HIDDEN or MASK type of nodes contains arrays of the corresponding
* values.
*
* Operations like Symmetrize are using GEOMETRY type of nodes which pushes the
* entire state of the mesh to the undo stack. This node contains all CustomData
* layers.
*
* The tricky aspect of this undo node type is that it stores mesh before and
* after modification. This allows the undo system to both undo and redo the
* symmetrize operation within the pre-modified-push of other node type
* behavior, but it uses more memory that it seems it should be.
*
* The dynamic topology undo nodes are handled somewhat separately from all
* other ones and the idea there is to store log of operations: which vertices
* and faces have been added or removed.
*
* Begin of dynamic topology sculpting mode have own node type. It contains an
* entire copy of mesh since just enabling the dynamic topology mode already
* does modifications on it.
*
* End of dynamic topology and symmetrize in this mode are handled in a special
* manner as well. */
#define NO_ACTIVE_LAYER bke::AttrDomain::Auto
struct UndoSculpt {
Vector<std::unique_ptr<Node>> nodes;
size_t undo_size;
};
struct SculptAttrRef {
bke::AttrDomain domain;
eCustomDataType type;
char name[MAX_CUSTOMDATA_LAYER_NAME];
bool was_set;
};
struct SculptUndoStep {
UndoStep step;
/* NOTE: will split out into list for multi-object-sculpt-mode. */
UndoSculpt data;
/* Active color attribute at the start of this undo step. */
SculptAttrRef active_color_start;
/* Active color attribute at the end of this undo step. */
SculptAttrRef active_color_end;
bContext *C;
#ifdef SCULPT_UNDO_DEBUG
int id;
#endif
};
static UndoSculpt *get_nodes();
static void sculpt_save_active_attribute(Object *ob, SculptAttrRef *attr);
static UndoSculpt *sculpt_undosys_step_get_nodes(UndoStep *us_p);
#ifdef SCULPT_UNDO_DEBUG
# ifdef _
# undef _
# endif
# define _(type) \
case type: \
return #type;
static char *undo_type_to_str(int type)
{
switch (type) {
_(Type::DyntopoBegin)
_(Type::DyntopoEnd)
_(Type::Position)
_(Type::Geometry)
_(Type::DyntopoSymmetrize)
_(Type::FaceSet)
_(Type::HideVert)
_(Type::HideFace)
_(Type::Mask)
_(Type::Color)
default:
return "unknown node type";
}
}
# undef _
static int nodeidgen = 1;
static void print_sculpt_node(Object *ob, Node *node)
{
printf(" %s:%s {applied=%d}\n", undo_type_to_str(node->type), node->idname, node->applied);
if (node->bm_entry) {
BM_log_print_entry(ob->sculpt ? ob->sculpt->bm : nullptr, node->bm_entry);
}
}
static void print_step(Object *ob, UndoStep *us, UndoStep *active, int i)
{
Node *node;
if (us->type != BKE_UNDOSYS_TYPE_SCULPT) {
printf("%d %s (non-sculpt): '%s', type:%s, use_memfile_step:%s\n",
i,
us == active ? "->" : " ",
us->name,
us->type->name,
us->use_memfile_step ? "true" : "false");
return;
}
int id = -1;
SculptUndoStep *su = (SculptUndoStep *)us;
if (!su->id) {
su->id = nodeidgen++;
}
id = su->id;
printf("id=%d %s %d %s (use_memfile_step=%s)\n",
id,
us == active ? "->" : " ",
i,
us->name,
us->use_memfile_step ? "true" : "false");
if (us->type == BKE_UNDOSYS_TYPE_SCULPT) {
UndoSculpt *usculpt = sculpt_undosys_step_get_nodes(us);
for (node = usculpt->nodes.first; node; node = node->next) {
print_sculpt_node(ob, node);
}
}
}
static void print_nodes(Object *ob, void *active)
{
printf("=================== Sculpt undo steps ==============\n");
UndoStack *ustack = ED_undo_stack_get();
UndoStep *us = ustack->steps.first;
if (active == nullptr) {
active = ustack->step_active;
}
if (!us) {
return;
}
printf("\n");
if (ustack->step_init) {
printf("===Undo initialization stepB===\n");
print_step(ob, ustack->step_init, active, -1);
printf("===============\n");
}
int i = 0, act_i = -1;
for (; us; us = us->next, i++) {
if (active == us) {
act_i = i;
}
print_step(ob, us, active, i);
}
if (ustack->step_active) {
printf("\n\n==Active step:==\n");
print_step(ob, ustack->step_active, active, act_i);
}
}
#else
static void print_nodes(Object * /*ob*/, void * /*active*/) {}
#endif
struct PartialUpdateData {
PBVH *pbvh;
bool changed_position;
bool changed_hide_vert;
bool changed_mask;
Span<bool> modified_grids;
Span<bool> modified_position_verts;
Span<bool> modified_hidden_verts;
Span<bool> modified_hidden_faces;
Span<bool> modified_mask_verts;
Span<bool> modified_color_verts;
Span<bool> modified_face_set_faces;
};
static void update_modified_node_mesh(PBVHNode &node, PartialUpdateData &data)
{
const Span<int> verts = BKE_pbvh_node_get_vert_indices(&node);
if (!data.modified_position_verts.is_empty()) {
for (const int vert : verts) {
if (data.modified_position_verts[vert]) {
BKE_pbvh_node_mark_positions_update(&node);
break;
}
}
}
if (!data.modified_mask_verts.is_empty()) {
for (const int vert : verts) {
if (data.modified_mask_verts[vert]) {
BKE_pbvh_node_mark_update_mask(&node);
break;
}
}
}
if (!data.modified_color_verts.is_empty()) {
for (const int vert : verts) {
if (data.modified_color_verts[vert]) {
BKE_pbvh_node_mark_update_color(&node);
break;
}
}
}
if (!data.modified_hidden_verts.is_empty()) {
for (const int vert : verts) {
if (data.modified_hidden_verts[vert]) {
BKE_pbvh_node_mark_update_visibility(&node);
break;
}
}
}
Vector<int> faces;
if (!data.modified_face_set_faces.is_empty()) {
if (faces.is_empty()) {
bke::pbvh::node_face_indices_calc_mesh(*data.pbvh, node, faces);
}
for (const int face : faces) {
if (data.modified_face_set_faces[face]) {
BKE_pbvh_node_mark_update_face_sets(&node);
break;
}
}
}
if (!data.modified_hidden_faces.is_empty()) {
if (faces.is_empty()) {
bke::pbvh::node_face_indices_calc_mesh(*data.pbvh, node, faces);
}
for (const int face : faces) {
if (data.modified_hidden_faces[face]) {
BKE_pbvh_node_mark_update_visibility(&node);
break;
}
}
}
}
static void update_modified_node_grids(PBVHNode &node, PartialUpdateData &data)
{
const Span<int> grid_indices = BKE_pbvh_node_get_grid_indices(node);
if (std::any_of(grid_indices.begin(), grid_indices.end(), [&](const int grid) {
return data.modified_grids[grid];
}))
{
if (data.changed_position) {
BKE_pbvh_node_mark_update(&node);
}
if (data.changed_mask) {
BKE_pbvh_node_mark_update_mask(&node);
}
if (data.changed_hide_vert) {
BKE_pbvh_node_mark_update_visibility(&node);
}
}
Vector<int> faces;
if (!data.modified_face_set_faces.is_empty()) {
if (faces.is_empty()) {
bke::pbvh::node_face_indices_calc_grids(*data.pbvh, node, faces);
}
for (const int face : faces) {
if (data.modified_face_set_faces[face]) {
BKE_pbvh_node_mark_update_face_sets(&node);
break;
}
}
}
if (!data.modified_hidden_faces.is_empty()) {
if (faces.is_empty()) {
bke::pbvh::node_face_indices_calc_grids(*data.pbvh, node, faces);
}
for (const int face : faces) {
if (data.modified_hidden_faces[face]) {
BKE_pbvh_node_mark_update_visibility(&node);
break;
}
}
}
}
static bool test_swap_v3_v3(float3 &a, float3 &b)
{
/* No need for float comparison here (memory is exactly equal or not). */
if (memcmp(a, b, sizeof(float[3])) != 0) {
std::swap(a, b);
return true;
}
return false;
}
static bool restore_deformed(
const SculptSession *ss, Node &unode, int uindex, int oindex, float3 &coord)
{
if (test_swap_v3_v3(coord, unode.orig_position[uindex])) {
copy_v3_v3(unode.position[uindex], ss->deform_cos[oindex]);
return true;
}
return false;
}
static bool restore_coords(
bContext *C, Object *ob, Depsgraph *depsgraph, Node &unode, MutableSpan<bool> modified_verts)
{
SculptSession *ss = ob->sculpt;
SubdivCCG *subdiv_ccg = ss->subdiv_ccg;
if (unode.mesh_verts_num) {
/* Regular mesh restore. */
if (ss->shapekey_active && !STREQ(ss->shapekey_active->name, unode.shapeName)) {
/* Shape key has been changed before calling undo operator. */
Key *key = BKE_key_from_object(ob);
KeyBlock *kb = key ? BKE_keyblock_find_name(key, unode.shapeName) : nullptr;
if (kb) {
ob->shapenr = BLI_findindex(&key->block, kb) + 1;
BKE_sculpt_update_object_for_edit(depsgraph, ob, false);
WM_event_add_notifier(C, NC_OBJECT | ND_DATA, ob);
}
else {
/* Key has been removed -- skip this undo node. */
return false;
}
}
/* No need for float comparison here (memory is exactly equal or not). */
const Span<int> index = unode.vert_indices.as_span().take_front(unode.unique_verts_num);
MutableSpan<float3> positions = ss->vert_positions;
if (ss->shapekey_active) {
float(*vertCos)[3] = BKE_keyblock_convert_to_vertcos(ob, ss->shapekey_active);
MutableSpan key_positions(reinterpret_cast<float3 *>(vertCos), ss->shapekey_active->totelem);
if (!unode.orig_position.is_empty()) {
if (ss->deform_modifiers_active) {
for (const int i : index.index_range()) {
restore_deformed(ss, unode, i, index[i], key_positions[index[i]]);
}
}
else {
for (const int i : index.index_range()) {
std::swap(key_positions[index[i]], unode.orig_position[i]);
}
}
}
else {
for (const int i : index.index_range()) {
std::swap(key_positions[index[i]], unode.position[i]);
}
}
/* Propagate new coords to keyblock. */
SCULPT_vertcos_to_key(ob, ss->shapekey_active, key_positions);
/* PBVH uses its own vertex array, so coords should be */
/* propagated to PBVH here. */
BKE_pbvh_vert_coords_apply(ss->pbvh, key_positions);
MEM_freeN(vertCos);
}
else {
if (!unode.orig_position.is_empty()) {
if (ss->deform_modifiers_active) {
for (const int i : index.index_range()) {
restore_deformed(ss, unode, i, index[i], positions[index[i]]);
modified_verts[index[i]] = true;
}
}
else {
for (const int i : index.index_range()) {
std::swap(positions[index[i]], unode.orig_position[i]);
modified_verts[index[i]] = true;
}
}
}
else {
for (const int i : index.index_range()) {
std::swap(positions[index[i]], unode.position[i]);
modified_verts[index[i]] = true;
}
}
}
}
else if (!unode.grids.is_empty() && subdiv_ccg != nullptr) {
const CCGKey key = BKE_subdiv_ccg_key_top_level(*subdiv_ccg);
const Span<int> grid_indices = unode.grids;
MutableSpan<float3> position = unode.position;
MutableSpan<CCGElem *> grids = subdiv_ccg->grids;
int index = 0;
for (const int i : grid_indices.index_range()) {
CCGElem *grid = grids[grid_indices[i]];
for (const int j : IndexRange(key.grid_area)) {
swap_v3_v3(CCG_elem_offset_co(&key, grid, j), position[index]);
index++;
}
}
}
return true;
}
static bool restore_hidden(Object *ob, Node &unode, MutableSpan<bool> modified_vertices)
{
SculptSession *ss = ob->sculpt;
SubdivCCG *subdiv_ccg = ss->subdiv_ccg;
if (unode.mesh_verts_num) {
Mesh &mesh = *static_cast<Mesh *>(ob->data);
bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
bke::SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_span<bool>(
".hide_vert", bke::AttrDomain::Point);
for (const int i : unode.vert_indices.index_range().take_front(unode.unique_verts_num)) {
const int vert = unode.vert_indices[i];
if (unode.vert_hidden[i].test() != hide_vert.span[vert]) {
unode.vert_hidden[i].set(!unode.vert_hidden[i].test());
hide_vert.span[vert] = !hide_vert.span[vert];
modified_vertices[vert] = true;
}
}
hide_vert.finish();
}
else if (!unode.grids.is_empty() && subdiv_ccg != nullptr) {
if (unode.grid_hidden.is_empty()) {
BKE_subdiv_ccg_grid_hidden_free(*subdiv_ccg);
return true;
}
BitGroupVector<> &grid_hidden = BKE_subdiv_ccg_grid_hidden_ensure(*subdiv_ccg);
const Span<int> grids = unode.grids;
for (const int i : grids.index_range()) {
/* Swap the two bit spans. */
MutableBoundedBitSpan a = unode.grid_hidden[i];
MutableBoundedBitSpan b = grid_hidden[grids[i]];
for (const int j : a.index_range()) {
const bool value_a = a[j];
const bool value_b = b[j];
a[j].set(value_b);
b[j].set(value_a);
}
}
}
return true;
}
static bool restore_hidden_face(Object &object, Node &unode, MutableSpan<bool> modified_faces)
{
Mesh &mesh = *static_cast<Mesh *>(object.data);
bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
bke::SpanAttributeWriter hide_poly = attributes.lookup_or_add_for_write_span<bool>(
".hide_poly", bke::AttrDomain::Face);
const Span<int> face_indices = unode.face_indices;
bool modified = false;
for (const int i : face_indices.index_range()) {
const int face = face_indices[i];
if (unode.face_hidden[i].test() != hide_poly.span[face]) {
unode.face_hidden[i].set(!unode.face_hidden[i].test());
hide_poly.span[face] = !hide_poly.span[face];
modified_faces[face] = true;
modified = true;
}
}
hide_poly.finish();
BKE_sculpt_hide_poly_pointer_update(object);
return modified;
}
static bool restore_color(Object *ob, Node &unode, MutableSpan<bool> modified_vertices)
{
SculptSession *ss = ob->sculpt;
bool modified = false;
/* NOTE: even with loop colors we still store derived
* vertex colors for original data lookup. */
if (!unode.col.is_empty() && unode.loop_col.is_empty()) {
BKE_pbvh_swap_colors(
ss->pbvh, unode.vert_indices.as_span().take_front(unode.unique_verts_num), unode.col);
modified = true;
}
Mesh *mesh = BKE_object_get_original_mesh(ob);
if (!unode.loop_col.is_empty() && unode.mesh_corners_num == mesh->corners_num) {
BKE_pbvh_swap_colors(ss->pbvh, unode.corner_indices, unode.loop_col);
modified = true;
}
if (modified) {
modified_vertices.fill_indices(unode.vert_indices.as_span(), true);
}
return modified;
}
static bool restore_mask(Object *ob, Node &unode, MutableSpan<bool> modified_vertices)
{
Mesh *mesh = BKE_object_get_original_mesh(ob);
SculptSession *ss = ob->sculpt;
SubdivCCG *subdiv_ccg = ss->subdiv_ccg;
if (unode.mesh_verts_num) {
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<float> mask = attributes.lookup_or_add_for_write_span<float>(
".sculpt_mask", bke::AttrDomain::Point);
const Span<int> index = unode.vert_indices.as_span().take_front(unode.unique_verts_num);
for (const int i : index.index_range()) {
const int vert = index[i];
if (mask.span[vert] != unode.mask[i]) {
std::swap(mask.span[vert], unode.mask[i]);
modified_vertices[vert] = true;
}
}
mask.finish();
}
else if (!unode.grids.is_empty() && subdiv_ccg != nullptr) {
const CCGKey key = BKE_subdiv_ccg_key_top_level(*subdiv_ccg);
MutableSpan<float> mask = unode.mask;
MutableSpan<CCGElem *> grids = subdiv_ccg->grids;
int index = 0;
for (const int grid : unode.grids) {
CCGElem *elem = grids[grid];
for (const int j : IndexRange(key.grid_area)) {
std::swap(*CCG_elem_offset_mask(&key, elem, j), mask[index]);
index++;
}
}
}
return true;
}
static bool restore_face_sets(Object *ob, Node &unode, MutableSpan<bool> modified_face_set_faces)
{
const Span<int> face_indices = unode.face_indices;
bke::SpanAttributeWriter<int> face_sets = face_set::ensure_face_sets_mesh(*ob);
bool modified = false;
for (const int i : face_indices.index_range()) {
const int face = face_indices[i];
if (unode.face_sets[i] == face_sets.span[face]) {
continue;
}
std::swap(unode.face_sets[i], face_sets.span[face]);
modified_face_set_faces[face] = true;
modified = true;
}
face_sets.finish();
return modified;
}
static void bmesh_restore_generic(Node &unode, Object *ob, SculptSession *ss)
{
if (unode.applied) {
BM_log_undo(ss->bm, ss->bm_log);
unode.applied = false;
}
else {
BM_log_redo(ss->bm, ss->bm_log);
unode.applied = true;
}
if (unode.type == Type::Mask) {
Vector<PBVHNode *> nodes = bke::pbvh::search_gather(ss->pbvh, {});
for (PBVHNode *node : nodes) {
BKE_pbvh_node_mark_redraw(node);
}
}
else {
SCULPT_pbvh_clear(ob);
}
}
/* Create empty sculpt BMesh and enable logging. */
static void bmesh_enable(Object *ob, Node &unode)
{
SculptSession *ss = ob->sculpt;
Mesh *mesh = static_cast<Mesh *>(ob->data);
SCULPT_pbvh_clear(ob);
/* Create empty BMesh and enable logging. */
BMeshCreateParams bmesh_create_params{};
bmesh_create_params.use_toolflags = false;
ss->bm = BM_mesh_create(&bm_mesh_allocsize_default, &bmesh_create_params);
BM_data_layer_add_named(ss->bm, &ss->bm->vdata, CD_PROP_FLOAT, ".sculpt_mask");
mesh->flag |= ME_SCULPT_DYNAMIC_TOPOLOGY;
/* Restore the BMLog using saved entries. */
ss->bm_log = BM_log_from_existing_entries_create(ss->bm, unode.bm_entry);
}
static void bmesh_restore_begin(bContext *C, Node &unode, Object *ob, SculptSession *ss)
{
if (unode.applied) {
dyntopo::disable(C, &unode);
unode.applied = false;
}
else {
bmesh_enable(ob, unode);
/* Restore the mesh from the first log entry. */
BM_log_redo(ss->bm, ss->bm_log);
unode.applied = true;
}
}
static void bmesh_restore_end(bContext *C, Node &unode, Object *ob, SculptSession *ss)
{
if (unode.applied) {
bmesh_enable(ob, unode);
/* Restore the mesh from the last log entry. */
BM_log_undo(ss->bm, ss->bm_log);
unode.applied = false;
}
else {
/* Disable dynamic topology sculpting. */
dyntopo::disable(C, nullptr);
unode.applied = true;
}
}
static void store_geometry_data(NodeGeometry *geometry, Object *object)
{
Mesh *mesh = static_cast<Mesh *>(object->data);
BLI_assert(!geometry->is_initialized);
geometry->is_initialized = true;
CustomData_copy(&mesh->vert_data, &geometry->vert_data, CD_MASK_MESH.vmask, mesh->verts_num);
CustomData_copy(&mesh->edge_data, &geometry->edge_data, CD_MASK_MESH.emask, mesh->edges_num);
CustomData_copy(
&mesh->corner_data, &geometry->corner_data, CD_MASK_MESH.lmask, mesh->corners_num);
CustomData_copy(&mesh->face_data, &geometry->face_data, CD_MASK_MESH.pmask, mesh->faces_num);
implicit_sharing::copy_shared_pointer(mesh->face_offset_indices,
mesh->runtime->face_offsets_sharing_info,
&geometry->face_offset_indices,
&geometry->face_offsets_sharing_info);
geometry->totvert = mesh->verts_num;
geometry->totedge = mesh->edges_num;
geometry->totloop = mesh->corners_num;
geometry->faces_num = mesh->faces_num;
}
static void restore_geometry_data(NodeGeometry *geometry, Object *object)
{
Mesh *mesh = static_cast<Mesh *>(object->data);
BLI_assert(geometry->is_initialized);
BKE_mesh_clear_geometry(mesh);
mesh->verts_num = geometry->totvert;
mesh->edges_num = geometry->totedge;
mesh->corners_num = geometry->totloop;
mesh->faces_num = geometry->faces_num;
mesh->totface_legacy = 0;
CustomData_copy(&geometry->vert_data, &mesh->vert_data, CD_MASK_MESH.vmask, geometry->totvert);
CustomData_copy(&geometry->edge_data, &mesh->edge_data, CD_MASK_MESH.emask, geometry->totedge);
CustomData_copy(
&geometry->corner_data, &mesh->corner_data, CD_MASK_MESH.lmask, geometry->totloop);
CustomData_copy(&geometry->face_data, &mesh->face_data, CD_MASK_MESH.pmask, geometry->faces_num);
implicit_sharing::copy_shared_pointer(geometry->face_offset_indices,
geometry->face_offsets_sharing_info,
&mesh->face_offset_indices,
&mesh->runtime->face_offsets_sharing_info);
}
static void geometry_free_data(NodeGeometry *geometry)
{
CustomData_free(&geometry->vert_data, geometry->totvert);
CustomData_free(&geometry->edge_data, geometry->totedge);
CustomData_free(&geometry->corner_data, geometry->totloop);
CustomData_free(&geometry->face_data, geometry->faces_num);
implicit_sharing::free_shared_data(&geometry->face_offset_indices,
&geometry->face_offsets_sharing_info);
}
static void restore_geometry(Node &unode, Object *object)
{
if (unode.geometry_clear_pbvh) {
SCULPT_pbvh_clear(object);
}
if (unode.applied) {
restore_geometry_data(&unode.geometry_modified, object);
unode.applied = false;
}
else {
restore_geometry_data(&unode.geometry_original, object);
unode.applied = true;
}
}
/* Handle all dynamic-topology updates
*
* Returns true if this was a dynamic-topology undo step, otherwise
* returns false to indicate the non-dyntopo code should run. */
static int bmesh_restore(bContext *C, Node &unode, Object *ob, SculptSession *ss)
{
switch (unode.type) {
case Type::DyntopoBegin:
bmesh_restore_begin(C, unode, ob, ss);
return true;
case Type::DyntopoEnd:
bmesh_restore_end(C, unode, ob, ss);
return true;
default:
if (ss->bm_log) {
bmesh_restore_generic(unode, ob, ss);
return true;
}
break;
}
return false;
}
/* Geometry updates (such as Apply Base, for example) will re-evaluate the object and refine its
* Subdiv descriptor. Upon undo it is required that mesh, grids, and subdiv all stay consistent
* with each other. This means that when geometry coordinate changes the undo should refine the
* subdiv to the new coarse mesh coordinates. Tricky part is: this needs to happen without using
* dependency graph tag: tagging object for geometry update will either loose sculpted data from
* the sculpt grids, or will wrongly "commit" them to the CD_MDISPS.
*
* So what we do instead is do minimum object evaluation to get base mesh coordinates for the
* multires modifier input. While this is expensive, it is less expensive than dependency graph
* evaluation and is only happening when geometry coordinates changes on undo.
*
* Note that the dependency graph is ensured to be evaluated prior to the undo step is decoded,
* so if the object's modifier stack references other object it is all fine. */
static void refine_subdiv(Depsgraph *depsgraph, SculptSession *ss, Object *object, Subdiv *subdiv)
{
Array<float3> deformed_verts = BKE_multires_create_deformed_base_mesh_vert_coords(
depsgraph, object, ss->multires.modifier);
BKE_subdiv_eval_refine_from_mesh(subdiv,
static_cast<const Mesh *>(object->data),
reinterpret_cast<float(*)[3]>(deformed_verts.data()));
}
static void restore_list(bContext *C, Depsgraph *depsgraph, UndoSculpt &usculpt)
{
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
RegionView3D *rv3d = CTX_wm_region_view3d(C);
BKE_view_layer_synced_ensure(scene, view_layer);
Object *ob = BKE_view_layer_active_object_get(view_layer);
SculptSession *ss = ob->sculpt;
SubdivCCG *subdiv_ccg = ss->subdiv_ccg;
bool clear_automask_cache = false;
for (const std::unique_ptr<Node> &unode : usculpt.nodes) {
if (!ELEM(unode->type, Type::Color, Type::Mask)) {
clear_automask_cache = true;
}
/* Restore pivot. */
copy_v3_v3(ss->pivot_pos, unode->pivot_pos);
copy_v3_v3(ss->pivot_rot, unode->pivot_rot);
}
if (clear_automask_cache) {
ss->last_automasking_settings_hash = 0;
}
if (!usculpt.nodes.is_empty()) {
/* Only do early object update for edits if first node needs this.
* Undo steps like geometry does not need object to be updated before they run and will
* ensure object is updated after the node is handled. */
const Node *first_unode = usculpt.nodes.first().get();
if (first_unode->type != Type::Geometry) {
BKE_sculpt_update_object_for_edit(depsgraph, ob, false);
}
if (bmesh_restore(C, *usculpt.nodes.first(), ob, ss)) {
return;
}
}
bool use_multires_undo = false;
bool changed_all_geometry = false;
bool changed_position = false;
bool changed_hide_vert = false;
bool changed_hide_face = false;
bool changed_mask = false;
bool changed_face_sets = false;
bool changed_color = false;
/* The PBVH already keeps track of which vertices need updated normals, but it doesn't keep
* track of other updates. In order to tell the corresponding PBVH nodes to update, keep track
* of which elements were updated for specific layers. */
Vector<bool> modified_verts_position;
Vector<bool> modified_verts_hide;
Vector<bool> modified_faces_hide;
Vector<bool> modified_verts_mask;
Vector<bool> modified_verts_color;
Vector<bool> modified_faces_face_set;
Vector<bool> modified_grids;
for (std::unique_ptr<Node> &unode : usculpt.nodes) {
if (!STREQ(unode->idname, ob->id.name)) {
continue;
}
/* Check if undo data matches current data well enough to continue. */
if (unode->mesh_verts_num) {
if (ss->totvert != unode->mesh_verts_num) {
continue;
}
}
else if (unode->maxgrid && subdiv_ccg != nullptr) {
if ((subdiv_ccg->grids.size() != unode->maxgrid) ||
(subdiv_ccg->grid_size != unode->gridsize))
{
continue;
}
use_multires_undo = true;
}
switch (unode->type) {
case Type::Position:
modified_verts_position.resize(ss->totvert, false);
if (restore_coords(C, ob, depsgraph, *unode, modified_verts_position)) {
changed_position = true;
}
break;
case Type::HideVert:
modified_verts_hide.resize(ss->totvert, false);
if (restore_hidden(ob, *unode, modified_verts_hide)) {
changed_hide_vert = true;
}
break;
case Type::HideFace:
modified_faces_hide.resize(ss->totfaces, false);
if (restore_hidden_face(*ob, *unode, modified_faces_hide)) {
changed_hide_face = true;
}
break;
case Type::Mask:
modified_verts_mask.resize(ss->totvert, false);
if (restore_mask(ob, *unode, modified_verts_mask)) {
changed_mask = true;
}
break;
case Type::FaceSet:
modified_faces_face_set.resize(ss->totfaces, false);
if (restore_face_sets(ob, *unode, modified_faces_face_set)) {
changed_face_sets = true;
}
break;
case Type::Color:
modified_verts_color.resize(ss->totvert, false);
if (restore_color(ob, *unode, modified_verts_color)) {
changed_color = true;
}
break;
case Type::Geometry:
restore_geometry(*unode, ob);
changed_all_geometry = true;
BKE_sculpt_update_object_for_edit(depsgraph, ob, false);
break;
case Type::DyntopoBegin:
case Type::DyntopoEnd:
case Type::DyntopoSymmetrize:
BLI_assert_msg(0, "Dynamic topology should've already been handled");
break;
}
}
if (use_multires_undo) {
for (std::unique_ptr<Node> &unode : usculpt.nodes) {
if (!STREQ(unode->idname, ob->id.name)) {
continue;
}
modified_grids.resize(unode->maxgrid, false);
modified_grids.as_mutable_span().fill_indices(unode->grids.as_span(), true);
}
}
if (subdiv_ccg != nullptr && changed_all_geometry) {
refine_subdiv(depsgraph, ss, ob, subdiv_ccg->subdiv);
}
DEG_id_tag_update(&ob->id, ID_RECALC_SHADING);
if (!changed_position && !changed_hide_vert && !changed_hide_face && !changed_mask &&
!changed_face_sets && !changed_color)
{
return;
}
/* We update all nodes still, should be more clever, but also
* needs to work correct when exiting/entering sculpt mode and
* the nodes get recreated, though in that case it could do all. */
PartialUpdateData data{};
data.changed_position = changed_position;
data.changed_hide_vert = changed_hide_vert;
data.changed_mask = changed_mask;
data.pbvh = ss->pbvh;
data.modified_grids = modified_grids;
data.modified_position_verts = modified_verts_position;
data.modified_hidden_verts = modified_verts_hide;
data.modified_hidden_faces = modified_faces_hide;
data.modified_mask_verts = modified_verts_mask;
data.modified_color_verts = modified_verts_color;
data.modified_face_set_faces = modified_faces_face_set;
if (use_multires_undo) {
bke::pbvh::search_callback(
*ss->pbvh, {}, [&](PBVHNode &node) { update_modified_node_grids(node, data); });
}
else {
bke::pbvh::search_callback(
*ss->pbvh, {}, [&](PBVHNode &node) { update_modified_node_mesh(node, data); });
}
if (changed_position) {
bke::pbvh::update_bounds(*ss->pbvh, PBVH_UpdateBB | PBVH_UpdateOriginalBB | PBVH_UpdateRedraw);
}
if (changed_mask) {
bke::pbvh::update_mask(*ss->pbvh);
}
if (changed_hide_face) {
hide::sync_all_from_faces(*ob);
bke::pbvh::update_visibility(*ss->pbvh);
}
if (changed_hide_vert) {
if (ELEM(BKE_pbvh_type(ss->pbvh), PBVH_FACES, PBVH_GRIDS)) {
Mesh &mesh = *static_cast<Mesh *>(ob->data);
BKE_pbvh_sync_visibility_from_verts(ss->pbvh, &mesh);
}
bke::pbvh::update_visibility(*ss->pbvh);
}
if (BKE_sculpt_multires_active(scene, ob)) {
if (changed_hide_vert) {
multires_mark_as_modified(depsgraph, ob, MULTIRES_HIDDEN_MODIFIED);
}
else if (changed_position) {
multires_mark_as_modified(depsgraph, ob, MULTIRES_COORDS_MODIFIED);
}
}
const bool tag_update = ID_REAL_USERS(ob->data) > 1 ||
!BKE_sculptsession_use_pbvh_draw(ob, rv3d) || ss->shapekey_active ||
ss->deform_modifiers_active;
if (tag_update) {
Mesh *mesh = static_cast<Mesh *>(ob->data);
if (changed_position) {
mesh->tag_positions_changed();
BKE_sculptsession_free_deformMats(ss);
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
}
static void free_list(UndoSculpt &usculpt)
{
for (std::unique_ptr<Node> &unode : usculpt.nodes) {
geometry_free_data(&unode->geometry_original);
geometry_free_data(&unode->geometry_modified);
geometry_free_data(&unode->geometry_bmesh_enter);
if (unode->bm_entry) {
BM_log_entry_drop(unode->bm_entry);
}
}
usculpt.nodes.~Vector();
}
Node *get_node(PBVHNode *node, Type type)
{
UndoSculpt *usculpt = get_nodes();
if (usculpt == nullptr) {
return nullptr;
}
for (std::unique_ptr<Node> &unode : usculpt->nodes) {
if (unode->node == node && unode->type == type) {
return unode.get();
}
}
return nullptr;
}
static size_t alloc_and_store_hidden(SculptSession *ss, Node *unode)
{
PBVHNode *node = static_cast<PBVHNode *>(unode->node);
if (!ss->subdiv_ccg) {
return 0;
}
const BitGroupVector<> grid_hidden = ss->subdiv_ccg->grid_hidden;
if (grid_hidden.is_empty()) {
return 0;
}
const Span<int> grid_indices = BKE_pbvh_node_get_grid_indices(*node);
unode->grid_hidden = BitGroupVector<>(grid_indices.size(), grid_hidden.group_size());
for (const int i : grid_indices.index_range()) {
unode->grid_hidden[i].copy_from(grid_hidden[grid_indices[i]]);
}
return unode->grid_hidden.all_bits().full_ints_num() / bits::BitsPerInt;
}
/* Allocate node and initialize its default fields specific for the given undo type.
* Will also add the node to the list in the undo step. */
static Node *alloc_node_type(Object *object, Type type)
{
UndoSculpt *usculpt = get_nodes();
std::unique_ptr<Node> unode = std::make_unique<Node>();
usculpt->nodes.append(std::move(unode));
usculpt->undo_size += sizeof(Node);
Node *node_ptr = usculpt->nodes.last().get();
STRNCPY(node_ptr->idname, object->id.name);
node_ptr->type = type;
return node_ptr;
}
/* Will return first existing undo node of the given type.
* If such node does not exist will allocate node of this type, register it in the undo step and
* return it. */
static Node *find_or_alloc_node_type(Object *object, Type type)
{
UndoSculpt *usculpt = get_nodes();
for (std::unique_ptr<Node> &unode : usculpt->nodes) {
if (unode->type == type) {
return unode.get();
}
}
return alloc_node_type(object, type);
}
static Node *alloc_node(Object *ob, PBVHNode *node, Type type)
{
UndoSculpt *usculpt = get_nodes();
SculptSession *ss = ob->sculpt;
Node *unode = alloc_node_type(ob, type);
unode->node = node;
int verts_num;
if (BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS) {
unode->maxgrid = ss->subdiv_ccg->grids.size();
unode->gridsize = ss->subdiv_ccg->grid_size;
verts_num = unode->maxgrid * unode->gridsize * unode->gridsize;
unode->grids = BKE_pbvh_node_get_grid_indices(*node);
usculpt->undo_size += unode->grids.as_span().size_in_bytes();
}
else {
unode->mesh_verts_num = ss->totvert;
unode->vert_indices = BKE_pbvh_node_get_vert_indices(node);
unode->unique_verts_num = BKE_pbvh_node_get_unique_vert_indices(node).size();
verts_num = unode->vert_indices.size();
usculpt->undo_size += unode->vert_indices.as_span().size_in_bytes();
}
bool need_loops = type == Type::Color;
const bool need_faces = ELEM(type, Type::FaceSet, Type::HideFace);
if (need_loops) {
unode->corner_indices = BKE_pbvh_node_get_corner_indices(node);
unode->mesh_corners_num = static_cast<Mesh *>(ob->data)->corners_num;
usculpt->undo_size += unode->corner_indices.as_span().size_in_bytes();
}
if (need_faces) {
if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES) {
bke::pbvh::node_face_indices_calc_mesh(*ss->pbvh, *node, unode->face_indices);
}
else {
bke::pbvh::node_face_indices_calc_grids(*ss->pbvh, *node, unode->face_indices);
}
usculpt->undo_size += unode->face_indices.as_span().size_in_bytes();
}
switch (type) {
case Type::Position: {
unode->position.reinitialize(verts_num);
usculpt->undo_size += unode->position.as_span().size_in_bytes();
/* Needed for original data lookup. */
unode->normal.reinitialize(verts_num);
usculpt->undo_size += unode->normal.as_span().size_in_bytes();
break;
}
case Type::HideVert: {
if (BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS) {
usculpt->undo_size += alloc_and_store_hidden(ss, unode);
}
else {
unode->vert_hidden.resize(unode->vert_indices.size());
usculpt->undo_size += unode->vert_hidden.size() / 8;
}
break;
}
case Type::HideFace: {
unode->face_hidden.resize(unode->face_indices.size());
usculpt->undo_size += unode->face_hidden.size() / 8;
break;
}
case Type::Mask: {
unode->mask.reinitialize(verts_num);
usculpt->undo_size += unode->mask.as_span().size_in_bytes();
break;
}
case Type::Color: {
/* Allocate vertex colors, even for loop colors we still
* need this for original data lookup. */
unode->col.reinitialize(verts_num);
usculpt->undo_size += unode->col.as_span().size_in_bytes();
/* Allocate loop colors separately too. */
if (ss->vcol_domain == bke::AttrDomain::Corner) {
unode->loop_col.reinitialize(unode->corner_indices.size());
unode->undo_size += unode->loop_col.as_span().size_in_bytes();
}
break;
}
case Type::DyntopoBegin:
case Type::DyntopoEnd:
case Type::DyntopoSymmetrize:
BLI_assert_msg(0, "Dynamic topology should've already been handled");
break;
case Type::Geometry:
break;
case Type::FaceSet: {
unode->face_sets.reinitialize(unode->face_indices.size());
usculpt->undo_size += unode->face_sets.as_span().size_in_bytes();
break;
}
}
if (ss->deform_modifiers_active) {
unode->orig_position.reinitialize(unode->vert_indices.size());
usculpt->undo_size += unode->orig_position.as_span().size_in_bytes();
}
return unode;
}
static void store_coords(Object *ob, Node *unode)
{
SculptSession *ss = ob->sculpt;
if (!unode->grids.is_empty()) {
const SubdivCCG &subdiv_ccg = *ss->subdiv_ccg;
const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
const Span<CCGElem *> grids = subdiv_ccg.grids;
{
int index = 0;
for (const int grid : unode->grids) {
CCGElem *elem = grids[grid];
for (const int i : IndexRange(key.grid_area)) {
unode->position[index] = float3(CCG_elem_offset_co(&key, elem, i));
index++;
}
}
}
if (key.has_normals) {
int index = 0;
for (const int grid : unode->grids) {
CCGElem *elem = grids[grid];
for (const int i : IndexRange(key.grid_area)) {
unode->normal[index] = float3(CCG_elem_offset_no(&key, elem, i));
index++;
}
}
}
}
else {
array_utils::gather(BKE_pbvh_get_vert_positions(ss->pbvh).as_span(),
unode->vert_indices.as_span(),
unode->position.as_mutable_span());
array_utils::gather(BKE_pbvh_get_vert_normals(ss->pbvh),
unode->vert_indices.as_span(),
unode->normal.as_mutable_span());
if (ss->deform_modifiers_active) {
array_utils::gather(ss->orig_cos.as_span(),
unode->vert_indices.as_span(),
unode->orig_position.as_mutable_span());
}
}
}
static void store_hidden(Object *ob, Node *unode)
{
if (!unode->grids.is_empty()) {
/* Already stored during allocation. */
}
const Mesh &mesh = *static_cast<const Mesh *>(ob->data);
const bke::AttributeAccessor attributes = mesh.attributes();
const VArraySpan<bool> hide_vert = *attributes.lookup<bool>(".hide_vert",
bke::AttrDomain::Point);
if (hide_vert.is_empty()) {
return;
}
PBVHNode *node = static_cast<PBVHNode *>(unode->node);
const Span<int> verts = BKE_pbvh_node_get_vert_indices(node);
for (const int i : verts.index_range()) {
unode->vert_hidden[i].set(hide_vert[verts[i]]);
}
}
static void store_face_hidden(Object &object, Node &unode)
{
const Mesh &mesh = *static_cast<const Mesh *>(object.data);
const bke::AttributeAccessor attributes = mesh.attributes();
const VArraySpan<bool> hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
if (hide_poly.is_empty()) {
unode.face_hidden.fill(false);
return;
}
const Span<int> faces = unode.face_indices;
for (const int i : faces.index_range()) {
unode.face_hidden[i].set(hide_poly[faces[i]]);
}
}
static void store_mask(Object *ob, Node *unode)
{
const SculptSession *ss = ob->sculpt;
if (!unode->grids.is_empty()) {
const SubdivCCG &subdiv_ccg = *ss->subdiv_ccg;
const CCGKey key = BKE_subdiv_ccg_key_top_level(subdiv_ccg);
if (key.has_mask) {
const Span<CCGElem *> grids = subdiv_ccg.grids;
int index = 0;
for (const int grid : unode->grids) {
CCGElem *elem = grids[grid];
for (const int i : IndexRange(key.grid_area)) {
unode->mask[index] = *CCG_elem_offset_mask(&key, elem, i);
index++;
}
}
}
else {
unode->mask.fill(0.0f);
}
}
else {
const Mesh &mesh = *static_cast<const Mesh *>(ob->data);
const bke::AttributeAccessor attributes = mesh.attributes();
if (const VArray mask = *attributes.lookup<float>(".sculpt_mask", bke::AttrDomain::Point)) {
array_utils::gather(mask, unode->vert_indices.as_span(), unode->mask.as_mutable_span());
}
else {
unode->mask.fill(0.0f);
}
}
}
static void store_color(Object *ob, Node *unode)
{
SculptSession *ss = ob->sculpt;
BLI_assert(BKE_pbvh_type(ss->pbvh) == PBVH_FACES);
/* NOTE: even with loop colors we still store (derived)
* vertex colors for original data lookup. */
BKE_pbvh_store_colors_vertex(
ss->pbvh, unode->vert_indices.as_span().take_front(unode->unique_verts_num), unode->col);
if (!unode->loop_col.is_empty() && !unode->corner_indices.is_empty()) {
BKE_pbvh_store_colors(ss->pbvh, unode->corner_indices, unode->loop_col);
}
}
static NodeGeometry *geometry_get(Node *unode)
{
if (!unode->geometry_original.is_initialized) {
return &unode->geometry_original;
}
BLI_assert(!unode->geometry_modified.is_initialized);
return &unode->geometry_modified;
}
static Node *geometry_push(Object *object, Type type)
{
Node *unode = find_or_alloc_node_type(object, type);
unode->applied = false;
unode->geometry_clear_pbvh = true;
NodeGeometry *geometry = geometry_get(unode);
store_geometry_data(geometry, object);
return unode;
}
static void store_face_sets(const Mesh &mesh, Node &unode)
{
array_utils::gather(
*mesh.attributes().lookup_or_default<int>(".sculpt_face_set", bke::AttrDomain::Face, 1),
unode.face_indices.as_span(),
unode.face_sets.as_mutable_span());
}
static Node *bmesh_push(Object *ob, PBVHNode *node, Type type)
{
UndoSculpt *usculpt = get_nodes();
SculptSession *ss = ob->sculpt;
Node *unode = usculpt->nodes.is_empty() ? nullptr : usculpt->nodes.first().get();
if (unode == nullptr) {
usculpt->nodes.append(std::make_unique<Node>());
unode = usculpt->nodes.last().get();
STRNCPY(unode->idname, ob->id.name);
unode->type = type;
unode->applied = true;
if (type == Type::DyntopoEnd) {
unode->bm_entry = BM_log_entry_add(ss->bm_log);
BM_log_before_all_removed(ss->bm, ss->bm_log);
}
else if (type == Type::DyntopoBegin) {
/* Store a copy of the mesh's current vertices, loops, and
* faces. A full copy like this is needed because entering
* dynamic-topology immediately does topological edits
* (converting faces to triangles) that the BMLog can't
* fully restore from. */
NodeGeometry *geometry = &unode->geometry_bmesh_enter;
store_geometry_data(geometry, ob);
unode->bm_entry = BM_log_entry_add(ss->bm_log);
BM_log_all_added(ss->bm, ss->bm_log);
}
else {
unode->bm_entry = BM_log_entry_add(ss->bm_log);
}
}
if (node) {
const int cd_vert_mask_offset = CustomData_get_offset_named(
&ss->bm->vdata, CD_PROP_FLOAT, ".sculpt_mask");
switch (type) {
case Type::Position:
case Type::Mask:
/* Before any vertex values get modified, ensure their
* original positions are logged. */
for (BMVert *vert : BKE_pbvh_bmesh_node_unique_verts(node)) {
BM_log_vert_before_modified(ss->bm_log, vert, cd_vert_mask_offset);
}
for (BMVert *vert : BKE_pbvh_bmesh_node_other_verts(node)) {
BM_log_vert_before_modified(ss->bm_log, vert, cd_vert_mask_offset);
}
break;
case Type::HideFace:
case Type::HideVert: {
for (BMVert *vert : BKE_pbvh_bmesh_node_unique_verts(node)) {
BM_log_vert_before_modified(ss->bm_log, vert, cd_vert_mask_offset);
}
for (BMVert *vert : BKE_pbvh_bmesh_node_other_verts(node)) {
BM_log_vert_before_modified(ss->bm_log, vert, cd_vert_mask_offset);
}
for (BMFace *f : BKE_pbvh_bmesh_node_faces(node)) {
BM_log_face_modified(ss->bm_log, f);
}
break;
}
case Type::DyntopoBegin:
case Type::DyntopoEnd:
case Type::DyntopoSymmetrize:
case Type::Geometry:
case Type::FaceSet:
case Type::Color:
break;
}
}
return unode;
}
Node *push_node(Object *ob, PBVHNode *node, Type type)
{
SculptSession *ss = ob->sculpt;
Node *unode;
/* List is manipulated by multiple threads, so we lock. */
BLI_thread_lock(LOCK_CUSTOM1);
ss->needs_flush_to_id = 1;
threading::isolate_task([&]() {
if (ss->bm || ELEM(type, Type::DyntopoBegin, Type::DyntopoEnd)) {
/* Dynamic topology stores only one undo node per stroke,
* regardless of the number of PBVH nodes modified. */
unode = bmesh_push(ob, node, type);
BLI_thread_unlock(LOCK_CUSTOM1);
// return unode;
return;
}
if (type == Type::Geometry) {
unode = geometry_push(ob, type);
BLI_thread_unlock(LOCK_CUSTOM1);
// return unode;
return;
}
if ((unode = get_node(node, type))) {
BLI_thread_unlock(LOCK_CUSTOM1);
// return unode;
return;
}
unode = alloc_node(ob, node, type);
/* NOTE: If this ever becomes a bottleneck, make a lock inside of the node.
* so we release global lock sooner, but keep data locked for until it is
* fully initialized. */
switch (type) {
case Type::Position:
store_coords(ob, unode);
break;
case Type::HideVert:
store_hidden(ob, unode);
break;
case Type::HideFace:
store_face_hidden(*ob, *unode);
break;
case Type::Mask:
store_mask(ob, unode);
break;
case Type::Color:
store_color(ob, unode);
break;
case Type::DyntopoBegin:
case Type::DyntopoEnd:
case Type::DyntopoSymmetrize:
BLI_assert_msg(0, "Dynamic topology should've already been handled");
case Type::Geometry:
break;
case Type::FaceSet:
store_face_sets(*static_cast<const Mesh *>(ob->data), *unode);
break;
}
BLI_thread_unlock(LOCK_CUSTOM1);
});
/* Store sculpt pivot. */
copy_v3_v3(unode->pivot_pos, ss->pivot_pos);
copy_v3_v3(unode->pivot_rot, ss->pivot_rot);
/* Store active shape key. */
if (ss->shapekey_active) {
STRNCPY(unode->shapeName, ss->shapekey_active->name);
}
else {
unode->shapeName[0] = '\0';
}
return unode;
}
static void sculpt_save_active_attribute(Object *ob, SculptAttrRef *attr)
{
Mesh *mesh = BKE_object_get_original_mesh(ob);
attr->was_set = true;
attr->domain = NO_ACTIVE_LAYER;
attr->name[0] = 0;
if (!mesh) {
return;
}
const char *name = mesh->active_color_attribute;
const bke::AttributeAccessor attributes = mesh->attributes();
const std::optional<bke::AttributeMetaData> meta_data = attributes.lookup_meta_data(name);
if (!meta_data) {
return;
}
if (!(ATTR_DOMAIN_AS_MASK(meta_data->domain) & ATTR_DOMAIN_MASK_COLOR) ||
!(CD_TYPE_AS_MASK(meta_data->data_type) & CD_MASK_COLOR_ALL))
{
return;
}
attr->domain = meta_data->domain;
STRNCPY(attr->name, name);
attr->type = meta_data->data_type;
}
void push_begin(Object *ob, const wmOperator *op)
{
push_begin_ex(ob, op->type->name);
}
void push_begin_ex(Object *ob, const char *name)
{
UndoStack *ustack = ED_undo_stack_get();
if (ob != nullptr) {
/* If possible, we need to tag the object and its geometry data as 'changed in the future' in
* the previous undo step if it's a memfile one. */
ED_undosys_stack_memfile_id_changed_tag(ustack, &ob->id);
ED_undosys_stack_memfile_id_changed_tag(ustack, static_cast<ID *>(ob->data));
}
/* Special case, we never read from this. */
bContext *C = nullptr;
SculptUndoStep *us = (SculptUndoStep *)BKE_undosys_step_push_init_with_type(
ustack, C, name, BKE_UNDOSYS_TYPE_SCULPT);
if (!us->active_color_start.was_set) {
sculpt_save_active_attribute(ob, &us->active_color_start);
}
/* Set end attribute in case push_end is not called,
* so we don't end up with corrupted state.
*/
if (!us->active_color_end.was_set) {
sculpt_save_active_attribute(ob, &us->active_color_end);
us->active_color_end.was_set = false;
}
}
void push_end(Object *ob)
{
push_end_ex(ob, false);
}
void push_end_ex(Object *ob, const bool use_nested_undo)
{
UndoSculpt *usculpt = get_nodes();
/* We don't need normals in the undo stack. */
for (std::unique_ptr<Node> &unode : usculpt->nodes) {
usculpt->undo_size -= unode->normal.as_span().size_in_bytes();
unode->normal = {};
}
/* We could remove this and enforce all callers run in an operator using 'OPTYPE_UNDO'. */
wmWindowManager *wm = static_cast<wmWindowManager *>(G_MAIN->wm.first);
if (wm->op_undo_depth == 0 || use_nested_undo) {
UndoStack *ustack = ED_undo_stack_get();
BKE_undosys_step_push(ustack, nullptr, nullptr);
if (wm->op_undo_depth == 0) {
BKE_undosys_stack_limit_steps_and_memory_defaults(ustack);
}
WM_file_tag_modified();
}
UndoStack *ustack = ED_undo_stack_get();
SculptUndoStep *us = (SculptUndoStep *)BKE_undosys_stack_init_or_active_with_type(
ustack, BKE_UNDOSYS_TYPE_SCULPT);
sculpt_save_active_attribute(ob, &us->active_color_end);
print_nodes(ob, nullptr);
}
/* -------------------------------------------------------------------- */
/** \name Implements ED Undo System
* \{ */
static void set_active_layer(bContext *C, SculptAttrRef *attr)
{
if (attr->domain == bke::AttrDomain::Auto) {
return;
}
Object *ob = CTX_data_active_object(C);
Mesh *mesh = BKE_object_get_original_mesh(ob);
SculptAttrRef existing;
sculpt_save_active_attribute(ob, &existing);
CustomDataLayer *layer = BKE_id_attribute_find(&mesh->id, attr->name, attr->type, attr->domain);
/* Temporary fix for #97408. This is a fundamental
* bug in the undo stack; the operator code needs to push
* an extra undo step before running an operator if a
* non-memfile undo system is active.
*
* For now, detect if the layer does exist but with a different
* domain and just unconvert it.
*/
if (!layer) {
layer = BKE_id_attribute_search_for_write(
&mesh->id, attr->name, CD_MASK_PROP_ALL, ATTR_DOMAIN_MASK_ALL);
if (layer) {
if (ED_geometry_attribute_convert(
mesh, attr->name, eCustomDataType(attr->type), attr->domain, nullptr))
{
layer = BKE_id_attribute_find(&mesh->id, attr->name, attr->type, attr->domain);
}
}
}
if (!layer) {
/* Memfile undo killed the layer; re-create it. */
mesh->attributes_for_write().add(
attr->name, attr->domain, attr->type, bke::AttributeInitDefaultValue());
layer = BKE_id_attribute_find(&mesh->id, attr->name, attr->type, attr->domain);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
if (layer) {
BKE_id_attributes_active_color_set(&mesh->id, layer->name);
if (ob->sculpt && ob->sculpt->pbvh) {
BKE_pbvh_update_active_vcol(ob->sculpt->pbvh, mesh);
}
}
}
static void sculpt_undosys_step_encode_init(bContext * /*C*/, UndoStep *us_p)
{
SculptUndoStep *us = (SculptUndoStep *)us_p;
new (&us->data.nodes) Vector<std::unique_ptr<Node>>();
}
static bool sculpt_undosys_step_encode(bContext * /*C*/, Main *bmain, UndoStep *us_p)
{
/* Dummy, encoding is done along the way by adding tiles
* to the current 'SculptUndoStep' added by encode_init. */
SculptUndoStep *us = (SculptUndoStep *)us_p;
us->step.data_size = us->data.undo_size;
Node *unode = us->data.nodes.is_empty() ? nullptr : us->data.nodes.last().get();
if (unode && unode->type == Type::DyntopoEnd) {
us->step.use_memfile_step = true;
}
us->step.is_applied = true;
if (!us->data.nodes.is_empty()) {
bmain->is_memfile_undo_flush_needed = true;
}
return true;
}
static void sculpt_undosys_step_decode_undo_impl(bContext *C,
Depsgraph *depsgraph,
SculptUndoStep *us)
{
BLI_assert(us->step.is_applied == true);
restore_list(C, depsgraph, us->data);
us->step.is_applied = false;
print_nodes(CTX_data_active_object(C), nullptr);
}
static void sculpt_undosys_step_decode_redo_impl(bContext *C,
Depsgraph *depsgraph,
SculptUndoStep *us)
{
BLI_assert(us->step.is_applied == false);
restore_list(C, depsgraph, us->data);
us->step.is_applied = true;
print_nodes(CTX_data_active_object(C), nullptr);
}
static void sculpt_undosys_step_decode_undo(bContext *C,
Depsgraph *depsgraph,
SculptUndoStep *us,
const bool is_final)
{
/* Walk forward over any applied steps of same type,
* then walk back in the next loop, un-applying them. */
SculptUndoStep *us_iter = us;
while (us_iter->step.next && (us_iter->step.next->type == us_iter->step.type)) {
if (us_iter->step.next->is_applied == false) {
break;
}
us_iter = (SculptUndoStep *)us_iter->step.next;
}
while ((us_iter != us) || (!is_final && us_iter == us)) {
BLI_assert(us_iter->step.type == us->step.type); /* Previous loop ensures this. */
set_active_layer(C, &((SculptUndoStep *)us_iter)->active_color_start);
sculpt_undosys_step_decode_undo_impl(C, depsgraph, us_iter);
if (us_iter == us) {
if (us_iter->step.prev && us_iter->step.prev->type == BKE_UNDOSYS_TYPE_SCULPT) {
set_active_layer(C, &((SculptUndoStep *)us_iter->step.prev)->active_color_end);
}
break;
}
us_iter = (SculptUndoStep *)us_iter->step.prev;
}
}
static void sculpt_undosys_step_decode_redo(bContext *C, Depsgraph *depsgraph, SculptUndoStep *us)
{
SculptUndoStep *us_iter = us;
while (us_iter->step.prev && (us_iter->step.prev->type == us_iter->step.type)) {
if (us_iter->step.prev->is_applied == true) {
break;
}
us_iter = (SculptUndoStep *)us_iter->step.prev;
}
while (us_iter && (us_iter->step.is_applied == false)) {
set_active_layer(C, &((SculptUndoStep *)us_iter)->active_color_end);
sculpt_undosys_step_decode_redo_impl(C, depsgraph, us_iter);
if (us_iter == us) {
set_active_layer(C, &((SculptUndoStep *)us_iter)->active_color_start);
break;
}
us_iter = (SculptUndoStep *)us_iter->step.next;
}
}
static void sculpt_undosys_step_decode(
bContext *C, Main *bmain, UndoStep *us_p, const eUndoStepDir dir, bool is_final)
{
/* NOTE: behavior for undo/redo closely matches image undo. */
BLI_assert(dir != STEP_INVALID);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
/* Ensure sculpt mode. */
{
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
BKE_view_layer_synced_ensure(scene, view_layer);
Object *ob = BKE_view_layer_active_object_get(view_layer);
if (ob && (ob->type == OB_MESH)) {
if (ob->mode & (OB_MODE_SCULPT | OB_MODE_VERTEX_PAINT)) {
/* Pass. */
}
else {
object::mode_generic_exit(bmain, depsgraph, scene, ob);
/* Sculpt needs evaluated state.
* NOTE: needs to be done here, as #object::mode_generic_exit will usually invalidate
* (some) evaluated data. */
BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
Mesh *mesh = static_cast<Mesh *>(ob->data);
/* Don't add sculpt topology undo steps when reading back undo state.
* The undo steps must enter/exit for us. */
mesh->flag &= ~ME_SCULPT_DYNAMIC_TOPOLOGY;
ED_object_sculptmode_enter_ex(bmain, depsgraph, scene, ob, true, nullptr);
}
if (ob->sculpt) {
ob->sculpt->needs_flush_to_id = 1;
}
bmain->is_memfile_undo_flush_needed = true;
}
else {
BLI_assert(0);
return;
}
}
SculptUndoStep *us = (SculptUndoStep *)us_p;
if (dir == STEP_UNDO) {
sculpt_undosys_step_decode_undo(C, depsgraph, us, is_final);
}
else if (dir == STEP_REDO) {
sculpt_undosys_step_decode_redo(C, depsgraph, us);
}
}
static void sculpt_undosys_step_free(UndoStep *us_p)
{
SculptUndoStep *us = (SculptUndoStep *)us_p;
free_list(us->data);
}
void geometry_begin(Object *ob, const wmOperator *op)
{
push_begin(ob, op);
push_node(ob, nullptr, Type::Geometry);
}
void geometry_begin_ex(Object *ob, const char *name)
{
push_begin_ex(ob, name);
push_node(ob, nullptr, Type::Geometry);
}
void geometry_end(Object *ob)
{
push_node(ob, nullptr, Type::Geometry);
push_end(ob);
}
void register_type(UndoType *ut)
{
ut->name = "Sculpt";
ut->poll = nullptr; /* No poll from context for now. */
ut->step_encode_init = sculpt_undosys_step_encode_init;
ut->step_encode = sculpt_undosys_step_encode;
ut->step_decode = sculpt_undosys_step_decode;
ut->step_free = sculpt_undosys_step_free;
ut->flags = UNDOTYPE_FLAG_DECODE_ACTIVE_STEP;
ut->step_size = sizeof(SculptUndoStep);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Utilities
* \{ */
static UndoSculpt *sculpt_undosys_step_get_nodes(UndoStep *us_p)
{
SculptUndoStep *us = (SculptUndoStep *)us_p;
return &us->data;
}
static UndoSculpt *get_nodes()
{
UndoStack *ustack = ED_undo_stack_get();
UndoStep *us = BKE_undosys_stack_init_or_active_with_type(ustack, BKE_UNDOSYS_TYPE_SCULPT);
return us ? sculpt_undosys_step_get_nodes(us) : nullptr;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Undo for changes happening on a base mesh for multires sculpting.
*
* Use this for multires operators which changes base mesh and which are to be
* possible. Example of such operators is Apply Base.
*
* Usage:
*
* static int operator_exec((bContext *C, wmOperator *op) {
*
* ED_sculpt_undo_push_mixed_begin(C, op->type->name);
* // Modify base mesh.
* ED_sculpt_undo_push_mixed_end(C, op->type->name);
*
* return OPERATOR_FINISHED;
* }
*
* If object is not in sculpt mode or sculpt does not happen on multires then
* regular ED_undo_push() is used.
* *
* \{ */
static bool use_multires_mesh(bContext *C)
{
if (BKE_paintmode_get_active_from_context(C) != PaintMode::Sculpt) {
return false;
}
Object *object = CTX_data_active_object(C);
SculptSession *sculpt_session = object->sculpt;
return sculpt_session->multires.active;
}
static void push_all_grids(Object *object)
{
SculptSession *ss = object->sculpt;
/* It is possible that undo push is done from an object state where there is no PBVH. This
* happens, for example, when an operation which tagged for geometry update was performed prior
* to the current operation without making any stroke in between.
*
* Skip pushing nodes based on the following logic: on redo Type::Position will
* ensure PBVH for the new base geometry, which will have same coordinates as if we create PBVH
* here.
*/
if (ss->pbvh == nullptr) {
return;
}
Vector<PBVHNode *> nodes = bke::pbvh::search_gather(ss->pbvh, {});
for (PBVHNode *node : nodes) {
Node *unode = push_node(object, node, Type::Position);
unode->node = nullptr;
}
}
void push_multires_mesh_begin(bContext *C, const char *str)
{
if (!use_multires_mesh(C)) {
return;
}
Object *object = CTX_data_active_object(C);
push_begin_ex(object, str);
Node *geometry_unode = push_node(object, nullptr, Type::Geometry);
geometry_unode->geometry_clear_pbvh = false;
push_all_grids(object);
}
void push_multires_mesh_end(bContext *C, const char *str)
{
if (!use_multires_mesh(C)) {
ED_undo_push(C, str);
return;
}
Object *object = CTX_data_active_object(C);
Node *geometry_unode = push_node(object, nullptr, Type::Geometry);
geometry_unode->geometry_clear_pbvh = false;
push_end(object);
}
/** \} */
} // namespace blender::ed::sculpt_paint::undo
Reference in New Issue View Git Blame Copy Permalink