copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions 1

Split mesh on erase

Browse source
This commit is contained in:
Yousef Khadadeh 2026-05-26 17:08:43 +03:00
parent 20a7e0bc37
commit c3fa1deee9
8 changed files with 168 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/CanvasComponents/CanvasComponent.cpp
View file

@ -75,6 +75,8 @@ bool CanvasComponent::can_erase_detail() const {
return false;
}
std::vector<CanvasComponentContainer*> CanvasComponent::attempt_split(DrawingProgram& drawP) const { return {}; }
CanvasComponentEraseDetailResult CanvasComponent::erase_detail(const SkPath& eraseAgainst) {
return CanvasComponentEraseDetailResult::NO_CHANGE;
}

1
src/CanvasComponents/CanvasComponent.hpp
View file

@ -41,6 +41,7 @@ class CanvasComponent {
virtual void get_used_resources(std::unordered_set<NetworkingObjects::NetObjID>& resourceSet) const;
virtual void remap_resource_ids(const std::unordered_map<NetworkingObjects::NetObjID, NetworkingObjects::NetObjID>& resourceOldToNewMap);
virtual void change_stroke_color(const Vector4f& newStrokeColor);
virtual std::vector<CanvasComponentContainer*> attempt_split(DrawingProgram& drawP) const;
virtual std::optional<Vector4f> get_stroke_color() const;
virtual void set_data_from(const CanvasComponent& other) = 0;

106
src/CanvasComponents/MeshCanvasComponent.cpp
View file

@ -33,9 +33,10 @@
#include "../DrawCollision.hpp"
#include "CanvasComponentContainer.hpp"
#include "Helpers/SCollision.hpp"
#include "../DrawingProgram/DrawingProgram.hpp"
#include "../World.hpp"
#include <CDT/include/CDT.h>
#define BVH_LEVELS 3
#include <clipper2/clipper.h>
template <typename Archive> void skpath_write(const SkPath& p, Archive& a) {
std::vector<uint32_t> contourSizes;
@ -106,6 +107,9 @@ void MeshCanvasComponent::load_file(cereal::PortableBinaryInputArchive& a, Versi
bool hasRoundCaps;
a(brushPoints, d.color, hasRoundCaps);
d.meshPath = BrushComponentCode::brush_stroke_to_skpath(brushPoints, hasRoundCaps);
std::optional<SkPath> simplified = Simplify(d.meshPath);
if(simplified.has_value())
d.meshPath = simplified.value();
}
}
@ -268,6 +272,104 @@ bool MeshCanvasComponent::can_erase_detail() const {
return true;
}
void sort_tree_into_sk_paths(std::vector<SkPath>& paths, const Clipper2Lib::PolyTreeD& tree) {
using namespace Clipper2Lib;
for(auto& treeChild : tree) {
SkPathBuilder newPath;
{
const PathD& poly = treeChild->Polygon();
if(poly.empty()) {
continue;
}
newPath.moveTo(poly.front().x, poly.front().y);
for(size_t i = 1; i < poly.size(); i++)
newPath.lineTo(poly[i].x, poly[i].y);
newPath.close();
}
for(auto& child : *treeChild) {
if(child->IsHole()) {
const PathD& poly = child->Polygon();
newPath.moveTo(poly.front().x, poly.front().y);
for(size_t i = 1; i < poly.size(); i++)
newPath.lineTo(poly[i].x, poly[i].y);
newPath.close();
for(auto& childChild : *child) {
if(childChild->IsHole())
continue;
else {
sort_tree_into_sk_paths(paths, *child);
}
}
}
else {
sort_tree_into_sk_paths(paths, *child);
}
}
paths.emplace_back(newPath.detach());
}
}
std::vector<CanvasComponentContainer*> MeshCanvasComponent::attempt_split(DrawingProgram& drawP) const {
using namespace Clipper2Lib;
std::vector<CanvasComponentContainer*> toRet;
PathsD clippingSubjects;
SkPath::Iter iter(d.meshPath, false);
size_t moveCount = 0;
for(;;) {
std::optional<SkPath::IterRec> rec = iter.next();
if(!rec.has_value())
break;
switch(rec->fVerb) {
case SkPathVerb::kClose:
break;
case SkPathVerb::kLine:
clippingSubjects.back().emplace_back(rec->fPoints[1].x(), rec->fPoints[1].y());
break;
case SkPathVerb::kMove:
clippingSubjects.emplace_back();
clippingSubjects.back().emplace_back(rec->fPoints[0].x(), rec->fPoints[0].y());
moveCount++;
break;
default:
throw std::runtime_error("[attempt_split] Illegal verb " + std::to_string(static_cast<unsigned>(rec->fVerb)));
break;
}
}
if(moveCount <= 1)
return {};
ClipperD clipper;
PolyTreeD solutionTree;
clipper.AddSubject(clippingSubjects);
clipper.AddClip(clippingSubjects);
clipper.Execute(ClipType::Union, FillRule::EvenOdd, solutionTree);
std::vector<SkPath> splitPaths;
sort_tree_into_sk_paths(splitPaths, solutionTree);
if(splitPaths.size() <= 1)
return toRet;
for(const SkPath& p : splitPaths) {
CanvasComponentContainer* newComp = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::MESH);
MeshCanvasComponent& mesh = static_cast<MeshCanvasComponent&>(newComp->get_comp());
mesh.d.color = d.color;
mesh.d.meshPath = p;
newComp->coords = compContainer->coords;
toRet.emplace_back(newComp);
}
return toRet;
}
CanvasComponentEraseDetailResult MeshCanvasComponent::erase_detail(const SkPath& eraseAgainst) {
bool intersectsAABB = d.meshPath.getBounds().intersects(eraseAgainst.getBounds());
if(!intersectsAABB)

1
src/CanvasComponents/MeshCanvasComponent.hpp
View file

@ -33,6 +33,7 @@ class MeshCanvasComponent : public CanvasComponent {
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
virtual std::unique_ptr<CanvasComponent> get_data_copy() const override;
virtual void change_stroke_color(const Vector4f& newStrokeColor) override;
virtual std::vector<CanvasComponentContainer*> attempt_split(DrawingProgram& drawP) const override;
virtual std::optional<Vector4f> get_stroke_color() const override;
virtual void set_data_from(const CanvasComponent& other) override;

25
src/DrawingProgram/Layers/DrawingProgramLayerManager.cpp
View file

@ -250,6 +250,12 @@ std::vector<CanvasComponentContainer::ObjInfoIterator> DrawingProgramLayerManage
return {};
}
std::vector<CanvasComponentContainer::ObjInfoIterator> DrawingProgramLayerManager::add_many_components_to_layer(DrawingProgramLayerListItem* layer, const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs, bool newUndo) {
auto toRet = layer->get_layer().components->insert_sorted_list_and_send_create(layer->get_layer().components, newObjs);
add_undo_place_components(layer, toRet, newUndo);
return toRet;
}
void DrawingProgramLayerManager::disable_add_to_cache_block(const std::function<void()>& toRun) {
addToCacheOnComponentInsert = false;
toRun();
@ -368,8 +374,8 @@ void DrawingProgramLayerManager::add_undo_place_component(CanvasComponentContain
drawP.world.undo.push(std::make_unique<AddCanvasComponentWorldUndoAction>(objInfo->pos, drawP.world.undo.get_undoid_from_netid(objInfo->obj.get_net_id()), drawP.world.undo.get_undoid_from_netid(objInfo->obj->parentLayer->get_layer().components.get_net_id())));
}
void DrawingProgramLayerManager::erase_component_map(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap) {
add_undo_erase_components(eraseMap);
void DrawingProgramLayerManager::erase_component_map(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap, bool newUndo) {
add_undo_erase_components(eraseMap, newUndo);
drawP.world.netObjMan.send_multi_update_messsage([&]() {
for(auto& [layerListItem, netObjSetToErase] : eraseMap) {
auto& layerComponentList = layerListItem->get_layer().components;
@ -378,7 +384,7 @@ void DrawingProgramLayerManager::erase_component_map(const std::unordered_map<Dr
}, NetworkingObjects::NetObjManager::SendUpdateType::SEND_TO_ALL, nullptr);
}
void DrawingProgramLayerManager::add_undo_erase_components(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap) {
void DrawingProgramLayerManager::add_undo_erase_components(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap, bool newUndo) {
using namespace NetworkingObjects;
struct EraseListData {
@ -485,10 +491,14 @@ void DrawingProgramLayerManager::add_undo_erase_components(const std::unordered_
++i;
}
}
undoMan.push(std::make_unique<EraseCanvasComponentsWorldUndoAction>(std::move(undoMap)));
if(newUndo)
undoMan.push(std::make_unique<EraseCanvasComponentsWorldUndoAction>(std::move(undoMap)));
else
undoMan.push_on_last(std::make_unique<EraseCanvasComponentsWorldUndoAction>(std::move(undoMap)));
}
void DrawingProgramLayerManager::add_undo_place_components(DrawingProgramLayerListItem* parent, const std::vector<CanvasComponentContainer::ObjInfoIterator>& placeList) {
void DrawingProgramLayerManager::add_undo_place_components(DrawingProgramLayerListItem* parent, const std::vector<CanvasComponentContainer::ObjInfoIterator>& placeList, bool newUndo) {
using namespace NetworkingObjects;
struct PlaceListData {
@ -575,5 +585,8 @@ void DrawingProgramLayerManager::add_undo_place_components(DrawingProgramLayerLi
undoData.pos.emplace_back(comp->pos - i);
++i;
}
undoMan.push(std::make_unique<PlaceCanvasComponentsWorldUndoAction>(undoMan.get_undoid_from_netid(parent->get_layer().components.get_net_id()), std::move(undoData)));
if(newUndo)
undoMan.push(std::make_unique<PlaceCanvasComponentsWorldUndoAction>(undoMan.get_undoid_from_netid(parent->get_layer().components.get_net_id()), std::move(undoData)));
else
undoMan.push_on_last(std::make_unique<PlaceCanvasComponentsWorldUndoAction>(undoMan.get_undoid_from_netid(parent->get_layer().components.get_net_id()), std::move(undoData)));
}

11
src/DrawingProgram/Layers/DrawingProgramLayerManager.hpp
View file

@ -31,9 +31,9 @@ class DrawingProgramLayerManager {
NetworkingObjects::NetObjOwnerPtr<DrawingProgramLayerListItem> layerTreeRoot;
NetworkingObjects::NetObjWeakPtr<DrawingProgramLayerListItem> editingLayer;
void set_initial_editing_layer();
void add_undo_erase_components(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap);
void add_undo_place_components(DrawingProgramLayerListItem* parent, const std::vector<CanvasComponentContainer::ObjInfoIterator>& placeList);
void erase_component_map(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap);
void add_undo_erase_components(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap, bool newUndo = true);
void add_undo_place_components(DrawingProgramLayerListItem* parent, const std::vector<CanvasComponentContainer::ObjInfoIterator>& placeList, bool newUndo = true);
void erase_component_map(const std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>>& eraseMap, bool newUndo = true);
bool commitUpdateOnComponentInsert = true;
bool addToCacheOnComponentInsert = true;
public:
@ -49,7 +49,7 @@ class DrawingProgramLayerManager {
void read_components_client(cereal::PortableBinaryInputArchive& a);
bool is_a_layer_being_edited();
void scale_up(const WorldScalar& scaleUpAmount);
template <typename List> void erase_component_container(const List& compsToErase) {
template <typename List> void erase_component_container(const List& compsToErase, bool newUndo = true) {
if(!compsToErase.empty()) {
std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>> idsToEraseInSpecificLayers;
for(auto& c : compsToErase)
@ -59,7 +59,7 @@ class DrawingProgramLayerManager {
return a->pos < b->pos;
});
}
erase_component_map(idsToEraseInSpecificLayers);
erase_component_map(idsToEraseInSpecificLayers, newUndo);
}
}
uint32_t edited_layer_component_count();
@ -80,6 +80,7 @@ class DrawingProgramLayerManager {
CanvasComponentContainer::ObjInfo* add_component_to_layer_being_edited(CanvasComponentContainer* newObj);
std::vector<CanvasComponentContainer::ObjInfoIterator> add_many_components_to_layer_being_edited(const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs);
std::vector<CanvasComponentContainer::ObjInfoIterator> add_many_components_to_layer(DrawingProgramLayerListItem* layer, const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs, bool newUndo = true);
std::vector<CanvasComponentContainer::ObjInfo*> get_flattened_component_list() const;
std::vector<DrawingProgramLayerListItem*> get_flattened_layer_list();
void add_undo_place_component(CanvasComponentContainer::ObjInfo* objInfo);

7
src/DrawingProgram/Tools/BrushTool.cpp
View file

@ -25,9 +25,9 @@
#include "../../CanvasComponents/MeshCanvasComponent.hpp"
#include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp"
#include "../../CanvasComponents/CanvasComponentContainer.hpp"
#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp"
#include <include/pathops/SkPathOps.h>
#define MINIMUM_DISTANCE_FROM_FIRST_POINT 3.0f
#define MINIMUM_DISTANCE_TO_NEXT_POINT 0.002f
@ -83,6 +83,11 @@ void BrushTool::commit_data(bool final) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
MeshCanvasComponent& newMesh = static_cast<MeshCanvasComponent&>(containerPtr->get_comp());
newMesh.d.meshPath = BrushComponentCode::brush_stroke_to_skpath(genData.brushPoints, drawP.world.main.toolConfig.brush.hasRoundCaps);
if(final) {
std::optional<SkPath> simplified = Simplify(newMesh.d.meshPath);
if(simplified.has_value())
newMesh.d.meshPath = simplified.value();
}
containerPtr->commit_update(drawP);
containerPtr->send_comp_update(drawP, final);
}

31
src/DrawingProgram/Tools/EraserTool.cpp
View file

@ -24,6 +24,7 @@
#include <include/core/SkPathBuilder.h>
#include "../../CanvasComponents/BrushComponentCode.hpp"
#include "../EditCanvasComponentWorldUndoAction.hpp"
#include <include/pathops/SkPathOps.h>
#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/RadioButtonHelpers.hpp"
@ -88,6 +89,10 @@ void EraserTool::input_mouse_button_on_canvas_callback(const InputManager::Mouse
isErasing = true;
}
else if(!button.down && isErasing) {
// If not real time eraser, we can benefit from simplifying the path
std::optional<SkPath> simplified = Simplify(erasePath);
if(simplified.has_value())
erasePath = simplified.value();
erase_on_path();
reset_erasing_stroke();
commit_erase();
@ -202,8 +207,30 @@ void EraserTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp)
}
void EraserTool::commit_erase() {
bool first = erasedComponents.empty(); // erase_component_container will call EraserTool::erase_component, which will clear erasedComponents eventually
drawP.layerMan.erase_component_container(erasedComponents);
bool placedNewObject = false;
std::unordered_map<DrawingProgramLayerListItem*, std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>> newObjectsToPlace;
std::erase_if(updatedComponents, [&] (auto& p) {
auto& [comp, oldData] = p;
std::vector<CanvasComponentContainer*> splitComps = comp->obj->get_comp().attempt_split(drawP);
if(!splitComps.empty()) {
for(CanvasComponentContainer* c : splitComps)
newObjectsToPlace[comp->obj->parentLayer].emplace_back(std::next(comp->obj->objInfo), c);
placedNewObject = true;
erasedComponents.emplace(comp);
comp->obj->get_comp().set_data_from(*oldData);
return true;
}
return false;
});
bool firstPlacement = true;
for(auto& [layer, compMap] : newObjectsToPlace) {
drawP.layerMan.add_many_components_to_layer(layer, compMap, firstPlacement);
firstPlacement = false;
}
bool objectsToErase = !erasedComponents.empty();
if(objectsToErase)
drawP.layerMan.erase_component_container(erasedComponents, !placedNewObject);
bool first = !objectsToErase && !placedNewObject;
for(auto& [comp, oldData] : updatedComponents) {
comp->obj->commit_update_dont_invalidate_cache(drawP);
comp->obj->send_comp_update(drawP, true);