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

Changed net object ordered list implementation

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-30 19:46:08 +03:00
parent 879655fbb8
commit fda8fcc166
60 changed files with 816 additions and 785 deletions
Download patch file Download diff file Expand all files Collapse all files

835
include/Helpers/NetworkingObjects/NetObjOrderedList.hpp
View file

File diff suppressed because it is too large Load diff

36
src/Bookmarks/BookmarkManager.cpp
View file

@ -43,10 +43,11 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
NetObjOrderedList<BookmarkListItem>& bookmarkParentFolder = *world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(parentId)->get_folder_list(); NetObjOrderedList<BookmarkListItem>& bookmarkParentFolder = *world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(parentId)->get_folder_list();
if(bookmarkParentFolder.size() <= index) if(bookmarkParentFolder.size() <= index)
return std::nullopt; return std::nullopt;
auto itemAtIndex = bookmarkParentFolder.at(index);
return GUIStuff::TreeListing::DisplayData::ObjInList{ return GUIStuff::TreeListing::DisplayData::ObjInList{
.id = bookmarkParentFolder.at(index)->obj.get_net_id(), .id = itemAtIndex->obj.get_net_id(),
.isDirectory = bookmarkParentFolder.at(index)->obj->is_folder(), .isDirectory = itemAtIndex->obj->is_folder(),
.isDirectoryOpen = bookmarkParentFolder.at(index)->obj->is_folder() ? bookmarkParentFolder.at(index)->obj->is_folder_open() : false .isDirectoryOpen = itemAtIndex->obj->is_folder() ? itemAtIndex->obj->is_folder_open() : false
}; };
}, },
.getIndexOfObjInList = [&](const GUIStuff::TreeListing::ParentObjectIDPair& idPair) { .getIndexOfObjInList = [&](const GUIStuff::TreeListing::ParentObjectIDPair& idPair) {
@ -92,28 +93,30 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
}, },
.moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) { .moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) {
world.netObjMan.send_multi_update_messsage([&]() { world.netObjMan.send_multi_update_messsage([&]() {
std::unordered_map<NetObjID, std::unordered_set<NetObjID>> toEraseMap; std::unordered_map<NetObjID, std::vector<NetObjOrderedListIterator<BookmarkListItem>>> toEraseMap;
uint32_t newIndex = index; uint32_t newIndex = index;
std::vector<NetObjOwnerPtr<BookmarkListItem>> toInsertObjPtrs; std::vector<NetObjOwnerPtr<BookmarkListItem>> toInsertObjPtrs;
auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listObj)->get_folder_list(); auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listObj)->get_folder_list();
for(size_t i = 0; i < objsToInsert.size(); i++) { for(size_t i = 0; i < objsToInsert.size(); i++) {
toEraseMap[objsToInsert[i].parent].emplace(objsToInsert[i].object); auto& parentListPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(objsToInsert[i].parent)->get_folder_list();
toEraseMap[objsToInsert[i].parent].emplace_back(parentListPtr->get(objsToInsert[i].object));
if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index) if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index)
newIndex--; newIndex--;
} }
for(auto& [listToEraseFrom, setToErase] : toEraseMap) { for(auto& [listToEraseFrom, setToErase] : toEraseMap) {
auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listToEraseFrom)->get_folder_list(); auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listToEraseFrom)->get_folder_list();
listToEraseFromPtr->erase_unordered_set(listToEraseFromPtr, setToErase, &toInsertObjPtrs); listToEraseFromPtr->erase_list(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
} }
std::vector<std::pair<uint32_t, NetObjOwnerPtr<BookmarkListItem>>> toInsert; std::vector<std::pair<NetObjOrderedListIterator<BookmarkListItem>, NetObjOwnerPtr<BookmarkListItem>>> toInsert;
auto insertIt = listPtr->at(newIndex);
for(uint32_t i = 0; i < objsToInsert.size(); i++) { for(uint32_t i = 0; i < objsToInsert.size(); i++) {
auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<BookmarkListItem>& objPtr) { auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<BookmarkListItem>& objPtr) {
return objPtr.get_net_id() == id; return objPtr.get_net_id() == id;
}); });
toInsert.emplace_back(newIndex + i, std::move(*it)); toInsert.emplace_back(insertIt, std::move(*it));
toInsert.back().second.reassign_ids(); toInsert.back().second.reassign_ids();
} }
listPtr->insert_ordered_list_and_send_create(listPtr, toInsert); listPtr->insert_ordered_list_and_send_create(listPtr, toInsert);
@ -138,7 +141,7 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
if(toDeleteObject.has_value()) { if(toDeleteObject.has_value()) {
auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(toDeleteParent.value())->get_folder_list(); auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(toDeleteParent.value())->get_folder_list();
folderList->erase(folderList, toDeleteObject.value()); folderList->erase(folderList, folderList->get(toDeleteObject.value()));
} }
} }
@ -169,30 +172,29 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
} }
} }
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> BookmarkManager::try_to_create_in_proper_position(BookmarkListItem* newItem) { std::optional<NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem>> BookmarkManager::try_to_create_in_proper_position(BookmarkListItem* newItem) {
using namespace NetworkingObjects; using namespace NetworkingObjects;
if(selectionData.orderedObjsSelected.empty()) if(selectionData.orderedObjsSelected.empty())
return nullptr; return std::nullopt;
auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back(); auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back();
NetObjTemporaryPtr<BookmarkListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.parent); NetObjTemporaryPtr<BookmarkListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.parent);
if(!parentPtr) if(!parentPtr)
return nullptr; return std::nullopt;
NetObjTemporaryPtr<BookmarkListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.object); NetObjTemporaryPtr<BookmarkListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.object);
if(!objectPtr) if(!objectPtr)
return nullptr; return std::nullopt;
if(objectPtr->is_folder()) { if(objectPtr->is_folder()) {
objectPtr->set_folder_open(true); objectPtr->set_folder_open(true);
return objectPtr->get_folder_list()->push_back_and_send_create(objectPtr->get_folder_list(), newItem); return objectPtr->get_folder_list()->push_back_and_send_create(objectPtr->get_folder_list(), newItem);
} }
uint32_t insertPos = parentPtr->get_folder_list()->get(objectPtr.get_net_id())->pos; return parentPtr->get_folder_list()->insert_and_send_create(parentPtr->get_folder_list(), std::next(parentPtr->get_folder_list()->get(objectPtr.get_net_id())), newItem);
return parentPtr->get_folder_list()->insert_and_send_create(parentPtr->get_folder_list(), insertPos + 1, newItem);
} }
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> BookmarkManager::create_in_proper_position(BookmarkListItem* newItem) { NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem> BookmarkManager::create_in_proper_position(BookmarkListItem* newItem) {
auto toRet = try_to_create_in_proper_position(newItem); auto toRet = try_to_create_in_proper_position(newItem);
if(!toRet) if(!toRet)
return bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), newItem); return bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), newItem);
return toRet; return toRet.value();
} }
void BookmarkManager::scale_up(const WorldScalar& scaleUpAmount) { void BookmarkManager::scale_up(const WorldScalar& scaleUpAmount) {

4
src/Bookmarks/BookmarkManager.hpp
View file

@ -23,8 +23,8 @@ class BookmarkManager {
NetworkingObjects::NetObjOwnerPtr<BookmarkListItem> bookmarkListRoot; NetworkingObjects::NetObjOwnerPtr<BookmarkListItem> bookmarkListRoot;
private: private:
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> create_in_proper_position(BookmarkListItem* newItem); NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem> create_in_proper_position(BookmarkListItem* newItem);
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> try_to_create_in_proper_position(BookmarkListItem* newItem); std::optional<NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem>> try_to_create_in_proper_position(BookmarkListItem* newItem);
GUIStuff::TreeListing::SelectionData selectionData; GUIStuff::TreeListing::SelectionData selectionData;
std::unordered_set<NetworkingObjects::NetObjID> oldSelection; std::unordered_set<NetworkingObjects::NetObjID> oldSelection;
std::string nameToEdit; std::string nameToEdit;

14
src/CanvasComponents/CanvasComponentContainer.cpp
View file

@ -74,25 +74,19 @@ void CanvasComponentContainer::draw(SkCanvas* canvas, const DrawData& drawData)
} }
} }
void CanvasComponentContainer::set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo) {
objInfo = ownerObjInfo;
}
void CanvasComponentContainer::commit_update(DrawingProgram& drawP) { void CanvasComponentContainer::commit_update(DrawingProgram& drawP) {
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo); drawP.preupdate_component(&(*objInfo));
get_comp().initialize_draw_data(drawP); get_comp().initialize_draw_data(drawP);
calculate_world_bounds(); calculate_world_bounds();
drawP.preupdate_component(lockedObjInfo); drawP.preupdate_component(&(*objInfo));
} }
void CanvasComponentContainer::commit_transform(DrawingProgram& drawP) { void CanvasComponentContainer::commit_transform(DrawingProgram& drawP) {
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo); drawP.preupdate_component(&(*objInfo));
calculate_world_bounds(); calculate_world_bounds();
drawP.preupdate_component(lockedObjInfo); drawP.preupdate_component(&(*objInfo));
} }
void CanvasComponentContainer::commit_update_dont_invalidate_cache(DrawingProgram& drawP) { void CanvasComponentContainer::commit_update_dont_invalidate_cache(DrawingProgram& drawP) {

6
src/CanvasComponents/CanvasComponentContainer.hpp
View file

@ -16,8 +16,7 @@ class CanvasComponentContainer {
typedef NetworkingObjects::NetObjOrderedList<CanvasComponentContainer> NetList; typedef NetworkingObjects::NetObjOrderedList<CanvasComponentContainer> NetList;
typedef NetworkingObjects::NetObjOwnerPtr<NetList> NetListOwnerPtr; typedef NetworkingObjects::NetObjOwnerPtr<NetList> NetListOwnerPtr;
typedef NetworkingObjects::NetObjOrderedListObjectInfo<CanvasComponentContainer> ObjInfo; typedef NetworkingObjects::NetObjOrderedListObjectInfo<CanvasComponentContainer> ObjInfo;
typedef std::shared_ptr<ObjInfo> ObjInfoSharedPtr; typedef NetworkingObjects::NetObjOrderedListIterator<CanvasComponentContainer> ObjInfoIterator;
typedef std::weak_ptr<ObjInfo> ObjInfoWeakPtr;
constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_COLLISIONS = 14; constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_COLLISIONS = 14;
constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_SCALING = 14; constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_SCALING = 14;
@ -50,12 +49,12 @@ class CanvasComponentContainer {
bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) const; bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) const;
bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam) const; bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) const; bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
void set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo);
void send_comp_update(DrawingProgram& drawP, bool finalUpdate); void send_comp_update(DrawingProgram& drawP, bool finalUpdate);
std::weak_ptr<DrawingProgramCacheBVHNode> cacheParentBvhNode; std::weak_ptr<DrawingProgramCacheBVHNode> cacheParentBvhNode;
DrawingProgramLayerListItem* parentLayer = nullptr; DrawingProgramLayerListItem* parentLayer = nullptr;
CoordSpaceHelper coords; CoordSpaceHelper coords;
ObjInfoIterator objInfo;
private: private:
friend class BrushStrokeCanvasComponent; friend class BrushStrokeCanvasComponent;
friend class ImageCanvasComponent; friend class ImageCanvasComponent;
@ -75,7 +74,6 @@ class CanvasComponentContainer {
TransformDrawData calculate_draw_transform(const DrawData& drawData) const; TransformDrawData calculate_draw_transform(const DrawData& drawData) const;
void calculate_world_bounds(); void calculate_world_bounds();
ObjInfoWeakPtr objInfo;
std::optional<SCollision::AABB<WorldScalar>> worldAABB; std::optional<SCollision::AABB<WorldScalar>> worldAABB;
NetworkingObjects::NetObjOwnerPtr<CanvasComponentAllocator> compAllocator; NetworkingObjects::NetObjOwnerPtr<CanvasComponentAllocator> compAllocator;
}; };

2
src/CanvasComponents/ImageCanvasComponent.cpp
View file

@ -79,7 +79,7 @@ void ImageCanvasComponent::update(DrawingProgram& drawP) {
ResourceDisplay* display = drawP.world.drawData.rMan->get_display_data(d.imageID); ResourceDisplay* display = drawP.world.drawData.rMan->get_display_data(d.imageID);
if(display) { if(display) {
if(display->update_draw()) if(display->update_draw())
drawP.invalidate_cache_at_component(compContainer->objInfo.lock()); drawP.invalidate_cache_at_component(&(*compContainer->objInfo));
} }
} }

8
src/DrawingProgram/DrawingProgram.cpp
View file

@ -288,12 +288,12 @@ void DrawingProgram::update() {
rebuild_cache(); rebuild_cache();
} }
void DrawingProgram::invalidate_cache_at_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) { void DrawingProgram::invalidate_cache_at_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(!selection.is_selected(objToCheck)) if(!selection.is_selected(objToCheck))
drawCache.invalidate_cache_at_aabb(objToCheck->obj->get_world_bounds()); drawCache.invalidate_cache_at_aabb(objToCheck->obj->get_world_bounds());
} }
void DrawingProgram::preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) { void DrawingProgram::preupdate_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(!selection.is_selected(objToCheck)) if(!selection.is_selected(objToCheck))
drawCache.preupdate_component(objToCheck); drawCache.preupdate_component(objToCheck);
} }
@ -395,7 +395,7 @@ void DrawingProgram::update_downloading_dropped_files() {
if(display->get_type() == ResourceDisplay::Type::FILE) { if(display->get_type() == ResourceDisplay::Type::FILE) {
Logger::get().log("WORLDFATAL", "Failed to parse image from URL"); Logger::get().log("WORLDFATAL", "Failed to parse image from URL");
auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components; auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components;
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj.get_net_id()); parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj->objInfo);
} }
else { else {
Vector2f imTrueDim = display->get_dimensions(); Vector2f imTrueDim = display->get_dimensions();
@ -414,7 +414,7 @@ void DrawingProgram::update_downloading_dropped_files() {
case FileDownloader::DownloadData::Status::FAILURE: { case FileDownloader::DownloadData::Status::FAILURE: {
Logger::get().log("WORLDFATAL", "Failed to download data from URL"); Logger::get().log("WORLDFATAL", "Failed to download data from URL");
auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components; auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components;
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj.get_net_id()); parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj->objInfo);
return true; return true;
} }
case FileDownloader::DownloadData::Status::IN_PROGRESS: case FileDownloader::DownloadData::Status::IN_PROGRESS:

8
src/DrawingProgram/DrawingProgram.hpp
View file

@ -50,8 +50,8 @@ class DrawingProgram {
void switch_to_tool_ptr(std::unique_ptr<DrawingProgramToolBase> newTool); void switch_to_tool_ptr(std::unique_ptr<DrawingProgramToolBase> newTool);
void modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& gridToModify); void modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& gridToModify);
void invalidate_cache_at_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck); void invalidate_cache_at_component(CanvasComponentContainer::ObjInfo* objToCheck);
void preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck); void preupdate_component(CanvasComponentContainer::ObjInfo* objToCheck);
private: private:
void drag_drop_update(); void drag_drop_update();
void add_file_to_canvas_by_path_execute(const std::filesystem::path& filePath, Vector2f dropPos); void add_file_to_canvas_by_path_execute(const std::filesystem::path& filePath, Vector2f dropPos);
@ -76,7 +76,7 @@ class DrawingProgram {
DrawingProgramSelection selection; DrawingProgramSelection selection;
std::unique_ptr<DrawingProgramToolBase> toolToSwitchToAfterUpdate; std::unique_ptr<DrawingProgramToolBase> toolToSwitchToAfterUpdate;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> updateableComponents; std::unordered_set<CanvasComponentContainer::ObjInfo*> updateableComponents;
bool temporaryEraser = false; bool temporaryEraser = false;
bool temporaryPan = false; bool temporaryPan = false;
@ -103,7 +103,7 @@ class DrawingProgram {
} controls; } controls;
struct DroppedDownloadingFile { struct DroppedDownloadingFile {
CanvasComponentContainer::ObjInfoSharedPtr comp; CanvasComponentContainer::ObjInfo* comp;
Vector2f windowSizeWhenDropped; Vector2f windowSizeWhenDropped;
std::shared_ptr<FileDownloader::DownloadData> downData; std::shared_ptr<FileDownloader::DownloadData> downData;
}; };

28
src/DrawingProgram/DrawingProgramCache.cpp
View file

@ -17,12 +17,12 @@ DrawingProgramCache::DrawingProgramCache(DrawingProgram& initDrawP):
drawP(initDrawP) drawP(initDrawP)
{} {}
void DrawingProgramCache::add_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) { void DrawingProgramCache::add_component(CanvasComponentContainer::ObjInfo* c) {
unsortedComponents.emplace_back(c); unsortedComponents.emplace_back(c);
invalidate_cache_at_aabb(c->obj->get_world_bounds()); invalidate_cache_at_aabb(c->obj->get_world_bounds());
} }
void DrawingProgramCache::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) { void DrawingProgramCache::erase_component(CanvasComponentContainer::ObjInfo* c) {
auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock(); auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock();
if(cacheParentBvhNodeLock) { if(cacheParentBvhNodeLock) {
std::erase(cacheParentBvhNodeLock->components, c); std::erase(cacheParentBvhNodeLock->components, c);
@ -54,11 +54,11 @@ bool DrawingProgramCache::unsorted_components_exist() const {
return !unsortedComponents.empty(); return !unsortedComponents.empty();
} }
void DrawingProgramCache::build(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToExclude) { void DrawingProgramCache::build(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToExclude) {
internal_build(drawP.layerMan.get_flattened_component_list(), objsToExclude); internal_build(drawP.layerMan.get_flattened_component_list(), objsToExclude);
} }
void DrawingProgramCache::internal_build(std::vector<CanvasComponentContainer::ObjInfoSharedPtr> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToNotInclude) { void DrawingProgramCache::internal_build(std::vector<CanvasComponentContainer::ObjInfo*> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToNotInclude) {
std::erase_if(componentsToBuild, [&objsToNotInclude](auto& c) { std::erase_if(componentsToBuild, [&objsToNotInclude](auto& c) {
return objsToNotInclude.contains(c); return objsToNotInclude.contains(c);
}); });
@ -74,9 +74,9 @@ void DrawingProgramCache::clear_own_cached_surfaces() {
}); });
} }
CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramCache::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) { CanvasComponentContainer::ObjInfo* DrawingProgramCache::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC); auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC);
CanvasComponentContainer::ObjInfoSharedPtr p; CanvasComponentContainer::ObjInfo* p = nullptr;
traverse_bvh_run_function(cCWorld.bounds, [&](const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode) { traverse_bvh_run_function(cCWorld.bounds, [&](const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode) {
node_loop_components(bvhNode, [&](const auto& c) { node_loop_components(bvhNode, [&](const auto& c) {
if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with_world_coords(drawP.world.drawData.cam.c, cCWorld)) if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with_world_coords(drawP.world.drawData.cam.c, cCWorld))
@ -87,7 +87,7 @@ CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramCache::get_front_object
return p; return p;
} }
void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f) { void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(CanvasComponentContainer::ObjInfo* comp)> f) {
if(bvhNode) { if(bvhNode) {
std::erase_if(bvhNode->components, [&f](const auto& comp) { std::erase_if(bvhNode->components, [&f](const auto& comp) {
if(f(comp)) { if(f(comp)) {
@ -101,14 +101,14 @@ void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<Dr
std::erase_if(unsortedComponents, f); std::erase_if(unsortedComponents, f);
} }
void DrawingProgramCache::node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f) { void DrawingProgramCache::node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(CanvasComponentContainer::ObjInfo* comp)> f) {
if(bvhNode) if(bvhNode)
std::for_each(bvhNode->components.begin(), bvhNode->components.end(), f); std::for_each(bvhNode->components.begin(), bvhNode->components.end(), f);
else else
std::for_each(unsortedComponents.begin(), unsortedComponents.end(), f); std::for_each(unsortedComponents.begin(), unsortedComponents.end(), f);
} }
void DrawingProgramCache::preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) { void DrawingProgramCache::preupdate_component(CanvasComponentContainer::ObjInfo* c) {
// Can be called even if object isn't in cache yet. In that case, it'll just invalidate the cache at the object's AABB // Can be called even if object isn't in cache yet. In that case, it'll just invalidate the cache at the object's AABB
auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock(); auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock();
if(cacheParentBvhNodeLock) { if(cacheParentBvhNodeLock) {
@ -119,7 +119,7 @@ void DrawingProgramCache::preupdate_component(const CanvasComponentContainer::Ob
invalidate_cache_at_aabb(c->obj->get_world_bounds()); invalidate_cache_at_aabb(c->obj->get_world_bounds());
} }
void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& components) { void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfo*>& components) {
if(components.empty()) if(components.empty())
return; return;
@ -138,7 +138,7 @@ void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCac
WorldVec boundsCenter = bvhNode->bounds.center(); WorldVec boundsCenter = bvhNode->bounds.center();
std::array<std::vector<CanvasComponentContainer::ObjInfoSharedPtr>, 4> parts; std::array<std::vector<CanvasComponentContainer::ObjInfo*>, 4> parts;
for(auto& c : components) { for(auto& c : components) {
const auto& cAABB = c->obj->get_world_bounds(); const auto& cAABB = c->obj->get_world_bounds();
@ -338,11 +338,11 @@ void DrawingProgramCache::recursive_draw_layer_item_to_canvas(const DrawingProgr
layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(layerListItem.get_blend_mode())); layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(layerListItem.get_blend_mode()));
canvas->saveLayer(nullptr, &layerPaint); canvas->saveLayer(nullptr, &layerPaint);
if(layerListItem.is_folder()) { if(layerListItem.is_folder()) {
for(auto& p : layerListItem.get_folder().folderList->get_data() | std::views::reverse) for(auto& p : *layerListItem.get_folder().folderList | std::views::reverse)
recursive_draw_layer_item_to_canvas(*p->obj, canvas, drawData, drawBounds, nodesToDraw); recursive_draw_layer_item_to_canvas(*p.obj, canvas, drawData, drawBounds, nodesToDraw);
} }
else { else {
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> compsToDraw; std::vector<CanvasComponentContainer::ObjInfo*> compsToDraw;
for(auto& c : unsortedComponents) { for(auto& c : unsortedComponents) {
if(c->obj->parentLayer == &layerListItem && (!drawBounds.has_value() || SCollision::collide(drawBounds.value(), c->obj->get_world_bounds()))) if(c->obj->parentLayer == &layerListItem && (!drawBounds.has_value() || SCollision::collide(drawBounds.value(), c->obj->get_world_bounds())))
compsToDraw.emplace_back(c); compsToDraw.emplace_back(c);

22
src/DrawingProgram/DrawingProgramCache.hpp
View file

@ -8,7 +8,7 @@ struct DrawingProgramCacheBVHNode {
CoordSpaceHelper coords; CoordSpaceHelper coords;
Vector2i resolution; Vector2i resolution;
private: private:
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> components; std::vector<CanvasComponentContainer::ObjInfo*> components;
std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>> children; std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>> children;
friend class DrawingProgramCache; friend class DrawingProgramCache;
}; };
@ -20,22 +20,22 @@ class DrawingProgramCache {
static constexpr size_t MAXIMUM_DRAW_CACHE_SURFACES = 40; static constexpr size_t MAXIMUM_DRAW_CACHE_SURFACES = 40;
DrawingProgramCache(DrawingProgram& initDrawP); DrawingProgramCache(DrawingProgram& initDrawP);
void add_component(const CanvasComponentContainer::ObjInfoSharedPtr& c); void add_component(CanvasComponentContainer::ObjInfo* c);
void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& c); void erase_component(CanvasComponentContainer::ObjInfo* c);
void clear_own_cached_surfaces(); void clear_own_cached_surfaces();
void preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& c); void preupdate_component(CanvasComponentContainer::ObjInfo* c);
void build(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToExclude); void build(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToExclude);
void traverse_bvh_run_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f); void traverse_bvh_run_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void traverse_bvh_run_function_starting_at_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f); void traverse_bvh_run_function_starting_at_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void traverse_bvh_run_function_starting_at_node_no_collision_check(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f); void traverse_bvh_run_function_starting_at_node_no_collision_check(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f); void node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(CanvasComponentContainer::ObjInfo* comp)> f);
void node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f); void node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(CanvasComponentContainer::ObjInfo* comp)> f);
bool should_rebuild() const; bool should_rebuild() const;
void draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds); void draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds);
bool unsorted_components_exist() const; bool unsorted_components_exist() const;
void invalidate_cache_at_aabb(const SCollision::AABB<WorldScalar>& aabb); void invalidate_cache_at_aabb(const SCollision::AABB<WorldScalar>& aabb);
void refresh_all_draw_cache(const DrawData& drawData); void refresh_all_draw_cache(const DrawData& drawData);
CanvasComponentContainer::ObjInfoSharedPtr get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC); CanvasComponentContainer::ObjInfo* get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
~DrawingProgramCache(); ~DrawingProgramCache();
private: private:
struct NodeCache { struct NodeCache {
@ -46,14 +46,14 @@ class DrawingProgramCache {
}; };
static std::unordered_map<std::shared_ptr<DrawingProgramCacheBVHNode>, NodeCache> nodeCacheMap; static std::unordered_map<std::shared_ptr<DrawingProgramCacheBVHNode>, NodeCache> nodeCacheMap;
void internal_build(std::vector<CanvasComponentContainer::ObjInfoSharedPtr> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToNotInclude); void internal_build(std::vector<CanvasComponentContainer::ObjInfo*> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToNotInclude);
void build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& components); void build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfo*>& components);
void build_bvh_node_coords_and_resolution(DrawingProgramCacheBVHNode& node); void build_bvh_node_coords_and_resolution(DrawingProgramCacheBVHNode& node);
void refresh_draw_cache(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const DrawData& drawData); void refresh_draw_cache(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const DrawData& drawData);
void draw_cache_image_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode); void draw_cache_image_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode);
void recursive_draw_layer_item_to_canvas(const DrawingProgramLayerListItem& layerListItem, SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds, const std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>>& nodesToDraw); void recursive_draw_layer_item_to_canvas(const DrawingProgramLayerListItem& layerListItem, SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds, const std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>>& nodesToDraw);
std::shared_ptr<DrawingProgramCacheBVHNode> bvhRoot; std::shared_ptr<DrawingProgramCacheBVHNode> bvhRoot;
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> unsortedComponents; std::vector<CanvasComponentContainer::ObjInfo*> unsortedComponents;
DrawingProgram& drawP; DrawingProgram& drawP;
}; };

48
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -23,9 +23,9 @@ DrawingProgramSelection::DrawingProgramSelection(DrawingProgram& initDrawP):
{} {}
void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) { void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> selectedComponents; std::unordered_set<CanvasComponentContainer::ObjInfo*> selectedComponents;
if(frontObjectOnly) { if(frontObjectOnly) {
CanvasComponentContainer::ObjInfoSharedPtr a = drawP.drawCache.get_front_object_colliding_with_in_editing_layer(cC); CanvasComponentContainer::ObjInfo* a = drawP.drawCache.get_front_object_colliding_with_in_editing_layer(cC);
if(a) { if(a) {
selectedComponents.emplace(a); selectedComponents.emplace(a);
drawP.drawCache.erase_component(a); drawP.drawCache.erase_component(a);
@ -40,7 +40,7 @@ void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCo
void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) { void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
if(frontObjectOnly) { if(frontObjectOnly) {
CanvasComponentContainer::ObjInfoSharedPtr p = get_front_object_colliding_with_in_editing_layer(cC); CanvasComponentContainer::ObjInfo* p = get_front_object_colliding_with_in_editing_layer(cC);
if(p) { if(p) {
drawP.drawCache.add_component(p); drawP.drawCache.add_component(p);
selectedSet.erase(p); selectedSet.erase(p);
@ -60,7 +60,7 @@ void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const
calculate_aabb(); calculate_aabb();
} }
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingProgramSelection::erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector) { std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingProgramSelection::erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfo*>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector) {
auto toRet = [&](const auto& bvhNode) { auto toRet = [&](const auto& bvhNode) {
if(bvhNode && (bvhNode->coords.inverseScale << 9) < drawP.world.drawData.cam.c.inverseScale && if(bvhNode && (bvhNode->coords.inverseScale << 9) < drawP.world.drawData.cam.c.inverseScale &&
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.min)) && SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.min)) &&
@ -69,7 +69,7 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) { SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) {
drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds); drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds);
drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) { drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto& c) { drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) { if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
selectedComponents.emplace(c); selectedComponents.emplace(c);
return true; return true;
@ -80,7 +80,7 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
}); });
return false; return false;
} }
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto& c) { drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) { if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
selectedComponents.emplace(c); selectedComponents.emplace(c);
drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds()); drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());
@ -94,12 +94,12 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
return toRet; return toRet;
} }
void DrawingProgramSelection::add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection) { void DrawingProgramSelection::add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection) {
selectedSet.insert(newSelection.begin(), newSelection.end()); selectedSet.insert(newSelection.begin(), newSelection.end());
calculate_aabb(); calculate_aabb();
} }
void DrawingProgramSelection::set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection) { void DrawingProgramSelection::set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection) {
selectedSet = newSelection; selectedSet = newSelection;
calculate_aabb(); calculate_aabb();
} }
@ -117,7 +117,7 @@ bool DrawingProgramSelection::is_something_selected() {
return !selectedSet.empty(); return !selectedSet.empty();
} }
bool DrawingProgramSelection::is_selected(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) { bool DrawingProgramSelection::is_selected(CanvasComponentContainer::ObjInfo* objToCheck) {
return selectedSet.contains(objToCheck); return selectedSet.contains(objToCheck);
} }
@ -149,15 +149,15 @@ bool DrawingProgramSelection::mouse_collided_with_rotate_handle_point() {
void DrawingProgramSelection::commit_transform_selection() { void DrawingProgramSelection::commit_transform_selection() {
auto selectedSetTemp = selectedSet; auto selectedSetTemp = selectedSet;
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> a(selectedSet.begin(), selectedSet.end()); std::vector<CanvasComponentContainer::ObjInfo*> a(selectedSet.begin(), selectedSet.end());
std::vector<std::pair<CanvasComponentContainer::ObjInfoSharedPtr, CoordSpaceHelper>> transformsFrom; std::vector<std::pair<CanvasComponentContainer::ObjInfo*, CoordSpaceHelper>> transformsFrom;
for(auto& transformedObj : a) for(auto& transformedObj : a)
transformsFrom.emplace_back(transformedObj, transformedObj->obj->coords); transformsFrom.emplace_back(transformedObj, transformedObj->obj->coords);
for(auto& comp : a) { for(auto& comp : a) {
comp->obj->coords = selectionTransformCoords.other_coord_space_from_this_space(comp->obj->coords); comp->obj->coords = selectionTransformCoords.other_coord_space_from_this_space(comp->obj->coords);
comp->obj->commit_transform(drawP); comp->obj->commit_transform(drawP);
} }
std::vector<std::pair<CanvasComponentContainer::ObjInfoSharedPtr, CoordSpaceHelper>> transformsTo; std::vector<std::pair<CanvasComponentContainer::ObjInfo*, CoordSpaceHelper>> transformsTo;
std::vector<std::pair<NetworkingObjects::NetObjID, CoordSpaceHelper>> transformsToSend; std::vector<std::pair<NetworkingObjects::NetObjID, CoordSpaceHelper>> transformsToSend;
for(auto& transformedObj : a) { for(auto& transformedObj : a) {
transformsToSend.emplace_back(transformedObj->obj.get_net_id(), transformedObj->obj->coords); transformsToSend.emplace_back(transformedObj->obj.get_net_id(), transformedObj->obj->coords);
@ -296,7 +296,7 @@ void DrawingProgramSelection::delete_all() {
} }
} }
void DrawingProgramSelection::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) { void DrawingProgramSelection::erase_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(is_selected(objToCheck)) { if(is_selected(objToCheck)) {
selectedSet.erase(objToCheck); selectedSet.erase(objToCheck);
if(selectedSet.empty()) if(selectedSet.empty())
@ -304,9 +304,9 @@ void DrawingProgramSelection::erase_component(const CanvasComponentContainer::Ob
} }
} }
CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramSelection::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) { CanvasComponentContainer::ObjInfo* DrawingProgramSelection::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC); auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC);
CanvasComponentContainer::ObjInfoSharedPtr p; CanvasComponentContainer::ObjInfo* p = nullptr;
for(auto& c : selectedSet) { for(auto& c : selectedSet) {
if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC))
p = c; p = c;
@ -319,7 +319,7 @@ void DrawingProgramSelection::selection_to_clipboard() {
std::unordered_set<NetworkingObjects::NetObjID> resourceSet; std::unordered_set<NetworkingObjects::NetObjID> resourceSet;
for(auto& c : selectedSet) for(auto& c : selectedSet)
c->obj->get_comp().get_used_resources(resourceSet); c->obj->get_comp().get_used_resources(resourceSet);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> compVecSort(selectedSet.begin(), selectedSet.end()); std::vector<CanvasComponentContainer::ObjInfo*> compVecSort(selectedSet.begin(), selectedSet.end());
std::vector<DrawingProgramLayerListItem*> flattenedLayerList = drawP.layerMan.get_flattened_layer_list(); std::vector<DrawingProgramLayerListItem*> flattenedLayerList = drawP.layerMan.get_flattened_layer_list();
std::unordered_map<DrawingProgramLayerListItem*, size_t> flattenedLayerListOrder; std::unordered_map<DrawingProgramLayerListItem*, size_t> flattenedLayerListOrder;
for(size_t i = 0; i < flattenedLayerList.size(); i++) for(size_t i = 0; i < flattenedLayerList.size(); i++)
@ -342,7 +342,7 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
if(!drawP.is_selection_allowing_tool(drawP.drawTool->get_type())) if(!drawP.is_selection_allowing_tool(drawP.drawTool->get_type()))
drawP.switch_to_tool(DrawingProgramToolType::EDIT); drawP.switch_to_tool(DrawingProgramToolType::EDIT);
std::vector<std::pair<uint32_t, CanvasComponentContainer*>> placedComponents; std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>> placedComponents;
WorldVec mousePos = drawP.world.drawData.cam.c.from_space(pasteScreenPos); WorldVec mousePos = drawP.world.drawData.cam.c.from_space(pasteScreenPos);
WorldVec moveVec = drawP.world.main.clipboard.pos - mousePos; WorldVec moveVec = drawP.world.main.clipboard.pos - mousePos;
WorldMultiplier scaleMultiplier = WorldMultiplier(drawP.world.main.clipboard.inverseScale) / WorldMultiplier(drawP.world.drawData.cam.c.inverseScale); WorldMultiplier scaleMultiplier = WorldMultiplier(drawP.world.main.clipboard.inverseScale) / WorldMultiplier(drawP.world.drawData.cam.c.inverseScale);
@ -362,10 +362,12 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
newComponentContainer->get_comp().remap_resource_ids(resourceRemapIDs); newComponentContainer->get_comp().remap_resource_ids(resourceRemapIDs);
newComponentContainer->coords.translate(-moveVec); newComponentContainer->coords.translate(-moveVec);
newComponentContainer->coords.scale_about(mousePos, scaleMultiplier); newComponentContainer->coords.scale_about(mousePos, scaleMultiplier);
placedComponents.emplace_back(drawP.layerMan.edited_layer_component_count() + placedComponents.size(), newComponentContainer); placedComponents.emplace_back(drawP.layerMan.get_edited_layer_end_iterator(), newComponentContainer);
} }
auto newlyInsertedObjects = drawP.layerMan.add_many_components_to_layer_being_edited(placedComponents); auto newlyInsertedObjectIts = drawP.layerMan.add_many_components_to_layer_being_edited(placedComponents);
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> compSetInserted(newlyInsertedObjects.begin(), newlyInsertedObjects.end()); std::unordered_set<CanvasComponentContainer::ObjInfo*> compSetInserted;
for(auto& it : newlyInsertedObjectIts)
compSetInserted.emplace(&(*it));
set_to_selection(compSetInserted); set_to_selection(compSetInserted);
//drawP.add_undo_place_components(compSetInserted); //drawP.add_undo_place_components(compSetInserted);
} }
@ -375,7 +377,7 @@ bool DrawingProgramSelection::is_being_transformed() {
return transformOpHappening != TransformOperation::NONE; return transformOpHappening != TransformOperation::NONE;
} }
const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& DrawingProgramSelection::get_selected_set() { const std::unordered_set<CanvasComponentContainer::ObjInfo*>& DrawingProgramSelection::get_selected_set() {
return selectedSet; return selectedSet;
} }
@ -459,8 +461,8 @@ void DrawingProgramSelection::draw_components_recursive(const DrawingProgramLaye
//layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(displayData->blendMode)); // For selection, everything should just be in default blend mode (SrcOver) //layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(displayData->blendMode)); // For selection, everything should just be in default blend mode (SrcOver)
canvas->saveLayer(nullptr, &layerPaint); canvas->saveLayer(nullptr, &layerPaint);
if(layerItem.is_folder()) { if(layerItem.is_folder()) {
for(auto& p : layerItem.get_folder().folderList->get_data() | std::views::reverse) for(auto& p : *layerItem.get_folder().folderList | std::views::reverse)
draw_components_recursive(*p->obj, canvas, drawData); draw_components_recursive(*p.obj, canvas, drawData);
} }
else { else {
for(auto& c : selectedSet) { // Loop on selected set and not layer component list, since i'm assuming selected set will be small for(auto& c : selectedSet) { // Loop on selected set and not layer component list, since i'm assuming selected set will be small

16
src/DrawingProgram/DrawingProgramSelection.hpp
View file

@ -10,19 +10,19 @@ class DrawingProgramSelection {
DrawingProgramSelection(DrawingProgram& initDrawP); DrawingProgramSelection(DrawingProgram& initDrawP);
void add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly); void add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly); void remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck); void erase_component(CanvasComponentContainer::ObjInfo* objToCheck);
bool is_something_selected(); bool is_something_selected();
bool is_selected(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck); bool is_selected(CanvasComponentContainer::ObjInfo* objToCheck);
void draw_components(SkCanvas* canvas, const DrawData& drawData); void draw_components(SkCanvas* canvas, const DrawData& drawData);
void draw_gui(SkCanvas* canvas, const DrawData& drawData); void draw_gui(SkCanvas* canvas, const DrawData& drawData);
bool is_being_transformed(); bool is_being_transformed();
void update(); void update();
void deselect_all(); void deselect_all();
void paste_clipboard(Vector2f pasteScreenPos); void paste_clipboard(Vector2f pasteScreenPos);
const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& get_selected_set(); const std::unordered_set<CanvasComponentContainer::ObjInfo*>& get_selected_set();
void delete_all(); void delete_all();
void selection_to_clipboard(); void selection_to_clipboard();
CanvasComponentContainer::ObjInfoSharedPtr get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC); CanvasComponentContainer::ObjInfo* get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
private: private:
void draw_components_recursive(const DrawingProgramLayerListItem& layerItem, SkCanvas* canvas, const DrawData& drawData); void draw_components_recursive(const DrawingProgramLayerListItem& layerItem, SkCanvas* canvas, const DrawData& drawData);
bool mouse_collided_with_selection_aabb(); bool mouse_collided_with_selection_aabb();
@ -34,16 +34,16 @@ class DrawingProgramSelection {
void rebuild_cam_space(); void rebuild_cam_space();
Vector2f get_rotation_point_pos_from_angle(double angle); Vector2f get_rotation_point_pos_from_angle(double angle);
void set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection); void set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection);
void add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection); void add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection);
void calculate_aabb(); void calculate_aabb();
void reset_all(); void reset_all();
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector); std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfo*>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector);
SCollision::ColliderCollection<float> camSpaceSelection; SCollision::ColliderCollection<float> camSpaceSelection;
std::array<WorldVec, 4> selectionRectPoints; std::array<WorldVec, 4> selectionRectPoints;
CoordSpaceHelperTransform selectionTransformCoords; CoordSpaceHelperTransform selectionTransformCoords;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> selectedSet; std::unordered_set<CanvasComponentContainer::ObjInfo*> selectedSet;
SCollision::AABB<WorldScalar> initialSelectionAABB; SCollision::AABB<WorldScalar> initialSelectionAABB;
DrawingProgram& drawP; DrawingProgram& drawP;

35
src/DrawingProgram/Layers/DrawingProgramLayer.cpp
View file

@ -4,39 +4,40 @@
#include <Helpers/Parallel.hpp> #include <Helpers/Parallel.hpp>
void DrawingProgramLayer::draw(SkCanvas* canvas, const DrawData& drawData) const { void DrawingProgramLayer::draw(SkCanvas* canvas, const DrawData& drawData) const {
for(auto& p : components->get_data()) for(auto& p : *components)
p->obj->draw(canvas, drawData); p.obj->draw(canvas, drawData);
} }
void DrawingProgramLayer::set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const { void DrawingProgramLayer::set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const {
components->set_insert_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) { components->set_insert_callback([&](const CanvasComponentContainer::ObjInfoIterator& c) {
c->obj->set_owner_obj_info(c); c->obj->objInfo = c;
c->obj->parentLayer = &layerListItem; c->obj->parentLayer = &layerListItem;
c->obj->commit_update(layerMan.drawP); // Run commit update on insert so that world bounds are calculated c->obj->commit_update(layerMan.drawP); // Run commit update on insert so that world bounds are calculated
layerMan.drawP.drawCache.add_component(c); layerMan.drawP.drawCache.add_component(&(*c));
if(c->obj->get_comp().get_type() == CanvasComponentType::IMAGE) if(c->obj->get_comp().get_type() == CanvasComponentType::IMAGE)
layerMan.drawP.updateableComponents.emplace(c); layerMan.drawP.updateableComponents.emplace(&(*c));
}); });
components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) { components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoIterator& c) {
layerMan.drawP.selection.erase_component(c); layerMan.drawP.selection.erase_component(&(*c));
layerMan.drawP.drawCache.erase_component(c); layerMan.drawP.drawCache.erase_component(&(*c));
layerMan.drawP.drawTool->erase_component(c); layerMan.drawP.drawTool->erase_component(&(*c));
std::erase_if(layerMan.drawP.droppedDownloadingFiles, [&c](auto& downloadingFile) { std::erase_if(layerMan.drawP.droppedDownloadingFiles, [&c](auto& downloadingFile) {
return downloadingFile.comp == c; return downloadingFile.comp == &(*c);
}); });
layerMan.drawP.updateableComponents.erase(c); layerMan.drawP.updateableComponents.erase(&(*c));
}); });
components->set_move_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c, uint32_t oldPos) { components->set_move_callback([&](const CanvasComponentContainer::ObjInfoIterator& c, uint32_t oldPos) {
layerMan.drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds()); layerMan.drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());
}); });
} }
void DrawingProgramLayer::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const { void DrawingProgramLayer::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const {
parallel_loop_container(components->get_data(), [&layerMan](auto& comp) { parallel_loop_container(*components, [&layerMan](auto& comp) {
comp->obj->commit_update_dont_invalidate_cache(layerMan.drawP); comp.obj->commit_update_dont_invalidate_cache(layerMan.drawP);
}); });
} }
void DrawingProgramLayer::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const { void DrawingProgramLayer::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
objList.insert(objList.begin(), components->get_data().begin(), components->get_data().end()); for(auto& p : *components)
objList.emplace_back(&p);
} }

3
src/DrawingProgram/Layers/DrawingProgramLayer.hpp
View file

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp> #include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include "../../CanvasComponents/CanvasComponent.hpp" #include "../../CanvasComponents/CanvasComponent.hpp"
#include <vector>
class DrawingProgramLayerListItem; class DrawingProgramLayerListItem;
class DrawingProgramLayerManager; class DrawingProgramLayerManager;
@ -10,7 +11,7 @@ class DrawingProgramLayer {
void draw(SkCanvas* canvas, const DrawData& drawData) const; void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const; void set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const;
void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const; void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const; void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
CanvasComponentContainer::NetListOwnerPtr components; CanvasComponentContainer::NetListOwnerPtr components;
}; };

18
src/DrawingProgram/Layers/DrawingProgramLayerFolder.cpp
View file

@ -4,24 +4,24 @@
#include <Helpers/Parallel.hpp> #include <Helpers/Parallel.hpp>
void DrawingProgramLayerFolder::draw(SkCanvas* canvas, const DrawData& drawData) const { void DrawingProgramLayerFolder::draw(SkCanvas* canvas, const DrawData& drawData) const {
for(auto& p : folderList->get_data() | std::views::reverse) for(auto& p : (*folderList) | std::views::reverse)
p->obj->draw(canvas, drawData); p.obj->draw(canvas, drawData);
} }
void DrawingProgramLayerFolder::set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const { void DrawingProgramLayerFolder::set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const {
folderList->set_insert_callback([&](auto& c) { folderList->set_insert_callback([&](auto& c) {
c->obj->set_component_list_callbacks(layerMan); c->obj->set_component_list_callbacks(layerMan);
}); });
for(auto& listItem : folderList->get_data()) for(auto& listItem : *folderList)
listItem->obj->set_component_list_callbacks(layerMan); listItem.obj->set_component_list_callbacks(layerMan);
} }
void DrawingProgramLayerFolder::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const { void DrawingProgramLayerFolder::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const {
for(auto& listItem : folderList->get_data()) for(auto& listItem : *folderList)
listItem->obj->commit_update_dont_invalidate_cache(layerMan); listItem.obj->commit_update_dont_invalidate_cache(layerMan);
} }
void DrawingProgramLayerFolder::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const { void DrawingProgramLayerFolder::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
for(auto& listItem : folderList->get_data()) for(auto& listItem : (*folderList) | std::views::reverse)
listItem->obj->get_flattened_component_list(objList); listItem.obj->get_flattened_component_list(objList);
} }

2
src/DrawingProgram/Layers/DrawingProgramLayerFolder.hpp
View file

@ -12,7 +12,7 @@ class DrawingProgramLayerFolder {
void draw(SkCanvas* canvas, const DrawData& drawData) const; void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const; void set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const;
void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const; void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const; void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>> folderList; NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>> folderList;
bool isFolderOpen = false; bool isFolderOpen = false;

10
src/DrawingProgram/Layers/DrawingProgramLayerListItem.cpp
View file

@ -46,7 +46,7 @@ void DrawingProgramLayerListItem::commit_update_dont_invalidate_cache(DrawingPro
layerData->commit_update_dont_invalidate_cache(layerMan); layerData->commit_update_dont_invalidate_cache(layerMan);
} }
void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const { void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
if(folderData) if(folderData)
folderData->get_flattened_component_list(objList); folderData->get_flattened_component_list(objList);
else else
@ -55,8 +55,8 @@ void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<Canva
void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList) { void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList) {
if(folderData) { if(folderData) {
for(auto& c : folderData->folderList->get_data()) for(auto& c : *folderData->folderList)
c->obj->get_flattened_layer_list(objList); c.obj->get_flattened_layer_list(objList);
} }
else else
objList.emplace_back(this); objList.emplace_back(this);
@ -65,8 +65,8 @@ void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingPr
uint32_t DrawingProgramLayerListItem::get_component_count() const { uint32_t DrawingProgramLayerListItem::get_component_count() const {
if(folderData) { if(folderData) {
uint32_t toRet = 0; uint32_t toRet = 0;
for(auto& c : folderData->folderList->get_data()) for(auto& c : *folderData->folderList)
toRet += c->obj->get_component_count(); toRet += c.obj->get_component_count();
return toRet; return toRet;
} }
else else

2
src/DrawingProgram/Layers/DrawingProgramLayerListItem.hpp
View file

@ -26,7 +26,7 @@ class DrawingProgramLayerListItem {
void draw(SkCanvas* canvas, const DrawData& drawData) const; void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const; void set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const;
const std::string& get_name() const; const std::string& get_name() const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const; void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
void get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList); void get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList);
void set_alpha(DrawingProgramLayerManager& layerMan, float newAlpha) const; void set_alpha(DrawingProgramLayerManager& layerMan, float newAlpha) const;

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

@ -1,5 +1,6 @@
#include "DrawingProgramLayerManager.hpp" #include "DrawingProgramLayerManager.hpp"
#include "../../World.hpp" #include "../../World.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
DrawingProgramLayerManager::DrawingProgramLayerManager(DrawingProgram& drawProg): DrawingProgramLayerManager::DrawingProgramLayerManager(DrawingProgram& drawProg):
drawP(drawProg), // initialize drawP first for next objects to be initialized properly drawP(drawProg), // initialize drawP first for next objects to be initialized properly
@ -32,13 +33,17 @@ uint32_t DrawingProgramLayerManager::edited_layer_component_count() {
return editingLayer.lock()->get_layer().components->size(); return editingLayer.lock()->get_layer().components->size();
} }
CanvasComponentContainer::ObjInfoIterator DrawingProgramLayerManager::get_edited_layer_end_iterator() {
return editingLayer.lock()->get_layer().components->end();
}
void DrawingProgramLayerManager::draw(SkCanvas* canvas, const DrawData& drawData) { void DrawingProgramLayerManager::draw(SkCanvas* canvas, const DrawData& drawData) {
if(layerTreeRoot) if(layerTreeRoot)
layerTreeRoot->draw(canvas, drawData); layerTreeRoot->draw(canvas, drawData);
} }
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> DrawingProgramLayerManager::get_flattened_component_list() const { std::vector<CanvasComponentContainer::ObjInfo*> DrawingProgramLayerManager::get_flattened_component_list() const {
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> toRet; std::vector<CanvasComponentContainer::ObjInfo*> toRet;
layerTreeRoot->get_flattened_component_list(toRet); layerTreeRoot->get_flattened_component_list(toRet);
return toRet; return toRet;
} }
@ -57,17 +62,17 @@ const DrawingProgramLayerListItem& DrawingProgramLayerManager::get_layer_root()
return *layerTreeRoot; return *layerTreeRoot;
} }
void DrawingProgramLayerManager::erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& compsToErase) { void DrawingProgramLayerManager::erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& compsToErase) {
std::unordered_map<DrawingProgramLayerListItem*, std::unordered_set<NetworkingObjects::NetObjID>> idsToEraseInSpecificLayers; std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>> idsToEraseInSpecificLayers;
for(auto& c : compsToErase) for(auto& c : compsToErase)
idsToEraseInSpecificLayers[c->obj->parentLayer].emplace(c->obj.get_net_id()); idsToEraseInSpecificLayers[c->obj->parentLayer].emplace_back(c->obj->objInfo);
for(auto& [layerListItem, netObjSetToErase] : idsToEraseInSpecificLayers) { for(auto& [layerListItem, netObjSetToErase] : idsToEraseInSpecificLayers) {
auto& layerComponentList = layerListItem->get_layer().components; auto& layerComponentList = layerListItem->get_layer().components;
layerComponentList->erase_unordered_set(layerComponentList, netObjSetToErase); layerComponentList->erase_list(layerComponentList, netObjSetToErase);
} }
} }
bool DrawingProgramLayerManager::component_passes_layer_selector(const CanvasComponentContainer::ObjInfoSharedPtr& c, LayerSelector layerSelector) { bool DrawingProgramLayerManager::component_passes_layer_selector(CanvasComponentContainer::ObjInfo* c, LayerSelector layerSelector) {
switch(layerSelector) { switch(layerSelector) {
case LayerSelector::ALL_VISIBLE_LAYERS: case LayerSelector::ALL_VISIBLE_LAYERS:
return c->obj->parentLayer->get_visible(); return c->obj->parentLayer->get_visible();
@ -77,16 +82,16 @@ bool DrawingProgramLayerManager::component_passes_layer_selector(const CanvasCom
return false; return false;
} }
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> DrawingProgramLayerManager::add_many_components_to_layer_being_edited(const std::vector<std::pair<uint32_t, CanvasComponentContainer*>>& newObjs) { std::vector<CanvasComponentContainer::ObjInfoIterator> DrawingProgramLayerManager::add_many_components_to_layer_being_edited(const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs) {
auto editLayerPtr = editingLayer.lock(); auto editLayerPtr = editingLayer.lock();
if(!editLayerPtr) if(!editLayerPtr)
return {}; return {};
return editLayerPtr->get_layer().components->insert_ordered_list_and_send_create(editLayerPtr->get_layer().components, newObjs); return editLayerPtr->get_layer().components->insert_ordered_list_and_send_create(editLayerPtr->get_layer().components, newObjs);
} }
CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramLayerManager::add_component_to_layer_being_edited(CanvasComponentContainer* newObj) { CanvasComponentContainer::ObjInfo* DrawingProgramLayerManager::add_component_to_layer_being_edited(CanvasComponentContainer* newObj) {
auto editLayerPtr = editingLayer.lock(); auto editLayerPtr = editingLayer.lock();
if(!editLayerPtr) if(!editLayerPtr)
return nullptr; return nullptr;
return editLayerPtr->get_layer().components->push_back_and_send_create(editLayerPtr->get_layer().components, newObj); return &(*editLayerPtr->get_layer().components->push_back_and_send_create(editLayerPtr->get_layer().components, newObj));
} }

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

@ -1,6 +1,7 @@
#pragma once #pragma once
#include "DrawingProgramLayerListItem.hpp" #include "DrawingProgramLayerListItem.hpp"
#include "DrawingProgramLayerManagerGUI.hpp" #include "DrawingProgramLayerManagerGUI.hpp"
#include <unordered_set>
class DrawingProgramLayerManager { class DrawingProgramLayerManager {
private: private:
@ -23,16 +24,17 @@ class DrawingProgramLayerManager {
void write_components_server(cereal::PortableBinaryOutputArchive& a); void write_components_server(cereal::PortableBinaryOutputArchive& a);
void read_components_client(cereal::PortableBinaryInputArchive& a); void read_components_client(cereal::PortableBinaryInputArchive& a);
bool is_a_layer_being_edited(); bool is_a_layer_being_edited();
void erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& compsToErase); void erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& compsToErase);
uint32_t edited_layer_component_count(); uint32_t edited_layer_component_count();
bool component_passes_layer_selector(const CanvasComponentContainer::ObjInfoSharedPtr& c, LayerSelector layerSelector); CanvasComponentContainer::ObjInfoIterator get_edited_layer_end_iterator();
bool component_passes_layer_selector(CanvasComponentContainer::ObjInfo* c, LayerSelector layerSelector);
bool layer_tree_root_exists(); bool layer_tree_root_exists();
const DrawingProgramLayerListItem& get_layer_root(); const DrawingProgramLayerListItem& get_layer_root();
CanvasComponentContainer::ObjInfoSharedPtr add_component_to_layer_being_edited(CanvasComponentContainer* newObj); CanvasComponentContainer::ObjInfo* add_component_to_layer_being_edited(CanvasComponentContainer* newObj);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> add_many_components_to_layer_being_edited(const std::vector<std::pair<uint32_t, CanvasComponentContainer*>>& newObjs); std::vector<CanvasComponentContainer::ObjInfoIterator> add_many_components_to_layer_being_edited(const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> get_flattened_component_list() const; std::vector<CanvasComponentContainer::ObjInfo*> get_flattened_component_list() const;
std::vector<DrawingProgramLayerListItem*> get_flattened_layer_list(); std::vector<DrawingProgramLayerListItem*> get_flattened_layer_list();
DrawingProgramLayerManagerGUI listGUI; DrawingProgramLayerManagerGUI listGUI;
}; };

34
src/DrawingProgram/Layers/DrawingProgramLayerManagerGUI.cpp
View file

@ -1,9 +1,11 @@
#include "DrawingProgramLayerManagerGUI.hpp" #include "DrawingProgramLayerManagerGUI.hpp"
#include "DrawingProgramLayerListItem.hpp"
#include "DrawingProgramLayerManager.hpp" #include "DrawingProgramLayerManager.hpp"
#include "../DrawingProgram.hpp" #include "../DrawingProgram.hpp"
#include "../../World.hpp" #include "../../World.hpp"
#include "../../MainProgram.hpp" #include "../../MainProgram.hpp"
#include "Helpers/ConvertVec.hpp" #include "Helpers/ConvertVec.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
#include "SerializedBlendMode.hpp" #include "SerializedBlendMode.hpp"
DrawingProgramLayerManagerGUI::DrawingProgramLayerManagerGUI(DrawingProgramLayerManager& drawLayerMan): DrawingProgramLayerManagerGUI::DrawingProgramLayerManagerGUI(DrawingProgramLayerManager& drawLayerMan):
@ -97,28 +99,29 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
}, },
.moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) { .moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) {
world.netObjMan.send_multi_update_messsage([&]() { world.netObjMan.send_multi_update_messsage([&]() {
std::unordered_map<NetObjID, std::unordered_set<NetObjID>> toEraseMap; std::unordered_map<NetObjID, std::vector<NetObjOrderedListIterator<DrawingProgramLayerListItem>>> toEraseMap;
uint32_t newIndex = index; uint32_t newIndex = index;
std::vector<NetObjOwnerPtr<DrawingProgramLayerListItem>> toInsertObjPtrs; std::vector<NetObjOwnerPtr<DrawingProgramLayerListItem>> toInsertObjPtrs;
auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listObj)->get_folder().folderList; auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listObj)->get_folder().folderList;
for(size_t i = 0; i < objsToInsert.size(); i++) { for(size_t i = 0; i < objsToInsert.size(); i++) {
toEraseMap[objsToInsert[i].parent].emplace(objsToInsert[i].object); toEraseMap[objsToInsert[i].parent].emplace_back(listPtr->get(objsToInsert[i].object));
if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index) if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index)
newIndex--; newIndex--;
} }
for(auto& [listToEraseFrom, setToErase] : toEraseMap) { for(auto& [listToEraseFrom, setToErase] : toEraseMap) {
auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listToEraseFrom)->get_folder().folderList; auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listToEraseFrom)->get_folder().folderList;
listToEraseFromPtr->erase_unordered_set(listToEraseFromPtr, setToErase, &toInsertObjPtrs); listToEraseFromPtr->erase_list(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
} }
std::vector<std::pair<uint32_t, NetObjOwnerPtr<DrawingProgramLayerListItem>>> toInsert; std::vector<std::pair<NetObjOrderedListIterator<DrawingProgramLayerListItem>, NetObjOwnerPtr<DrawingProgramLayerListItem>>> toInsert;
auto insertIt = listPtr->at(newIndex);
for(uint32_t i = 0; i < objsToInsert.size(); i++) { for(uint32_t i = 0; i < objsToInsert.size(); i++) {
auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<DrawingProgramLayerListItem>& objPtr) { auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<DrawingProgramLayerListItem>& objPtr) {
return objPtr.get_net_id() == id; return objPtr.get_net_id() == id;
}); });
toInsert.emplace_back(newIndex + i, std::move(*it)); toInsert.emplace_back(insertIt, std::move(*it));
toInsert.back().second.reassign_ids(); toInsert.back().second.reassign_ids();
} }
listPtr->insert_ordered_list_and_send_create(listPtr, toInsert); listPtr->insert_ordered_list_and_send_create(listPtr, toInsert);
@ -151,7 +154,7 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
if(toDeleteObject.has_value()) { if(toDeleteObject.has_value()) {
auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(toDeleteParent.value())->get_folder().folderList; auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(toDeleteParent.value())->get_folder().folderList;
folderList->erase(folderList, toDeleteObject.value()); folderList->erase(folderList, folderList->get(toDeleteObject.value()));
} }
} }
@ -194,29 +197,28 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
} }
} }
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem) { std::optional<NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem>> DrawingProgramLayerManagerGUI::try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem) {
using namespace NetworkingObjects; using namespace NetworkingObjects;
auto& world = layerMan.drawP.world; auto& world = layerMan.drawP.world;
if(selectionData.orderedObjsSelected.empty()) if(selectionData.orderedObjsSelected.empty())
return nullptr; return std::nullopt;
auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back(); auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back();
NetObjTemporaryPtr<DrawingProgramLayerListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.parent); NetObjTemporaryPtr<DrawingProgramLayerListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.parent);
if(!parentPtr) if(!parentPtr)
return nullptr; return std::nullopt;
NetObjTemporaryPtr<DrawingProgramLayerListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.object); NetObjTemporaryPtr<DrawingProgramLayerListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.object);
if(!objectPtr) if(!objectPtr)
return nullptr; return std::nullopt;
if(objectPtr->is_folder()) { if(objectPtr->is_folder()) {
objectPtr->get_folder().isFolderOpen = true; objectPtr->get_folder().isFolderOpen = true;
return objectPtr->get_folder().folderList->insert_and_send_create(objectPtr->get_folder().folderList, 0, newItem); return objectPtr->get_folder().folderList->insert_and_send_create(objectPtr->get_folder().folderList, objectPtr->get_folder().folderList->begin(), newItem);
} }
uint32_t insertPos = parentPtr->get_folder().folderList->get(objectPtr.get_net_id())->pos; return parentPtr->get_folder().folderList->insert_and_send_create(parentPtr->get_folder().folderList, parentPtr->get_folder().folderList->get(objectPtr.get_net_id()), newItem);
return parentPtr->get_folder().folderList->insert_and_send_create(parentPtr->get_folder().folderList, insertPos, newItem);
} }
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::create_in_proper_position(DrawingProgramLayerListItem* newItem) { NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::create_in_proper_position(DrawingProgramLayerListItem* newItem) {
auto toRet = try_to_create_in_proper_position(newItem); auto toRet = try_to_create_in_proper_position(newItem);
if(!toRet) if(!toRet)
return layerMan.layerTreeRoot->get_folder().folderList->insert_and_send_create(layerMan.layerTreeRoot->get_folder().folderList, 0, newItem); return layerMan.layerTreeRoot->get_folder().folderList->insert_and_send_create(layerMan.layerTreeRoot->get_folder().folderList, layerMan.layerTreeRoot->get_folder().folderList->begin(), newItem);
return toRet; return toRet.value();
} }

4
src/DrawingProgram/Layers/DrawingProgramLayerManagerGUI.hpp
View file

@ -13,8 +13,8 @@ class DrawingProgramLayerManagerGUI {
void refresh_gui_data(); void refresh_gui_data();
void setup_list_gui(const std::string& id, bool& hoveringOverDropdown); void setup_list_gui(const std::string& id, bool& hoveringOverDropdown);
private: private:
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem); std::optional<NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem>> try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem);
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> create_in_proper_position(DrawingProgramLayerListItem* newItem); NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem> create_in_proper_position(DrawingProgramLayerListItem* newItem);
GUIStuff::TreeListing::SelectionData selectionData; GUIStuff::TreeListing::SelectionData selectionData;
std::unordered_set<NetworkingObjects::NetObjID> oldSelection; std::unordered_set<NetworkingObjects::NetObjID> oldSelection;

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

@ -26,11 +26,9 @@ void BrushTool::switch_tool(DrawingProgramToolType newTool) {
commit_stroke(); commit_stroke();
} }
void BrushTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void BrushTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp) { if(objInfoBeingEdited == erasedComp)
isDrawing = false;
objInfoBeingEdited = nullptr; objInfoBeingEdited = nullptr;
}
} }
bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) { bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) {
@ -59,7 +57,7 @@ void BrushTool::tool_update() {
if(drawP.controls.cursorHoveringOverCanvas) if(drawP.controls.cursorHoveringOverCanvas)
drawP.world.main.input.hideCursor = true; drawP.world.main.input.hideCursor = true;
if(!isDrawing) if(!objInfoBeingEdited)
penSmoothingData.clear(); penSmoothingData.clear();
if(drawP.world.main.input.pen.isDown && drawP.controls.leftClickHeld && drawP.world.main.toolbar.tabletOptions.pressureAffectsBrushWidth) { if(drawP.world.main.input.pen.isDown && drawP.controls.leftClickHeld && drawP.world.main.toolbar.tabletOptions.pressureAffectsBrushWidth) {
@ -89,9 +87,8 @@ void BrushTool::tool_update() {
isPenDown = true; isPenDown = true;
if(isPenDown) { if(isPenDown) {
if(!isDrawing) { if(!objInfoBeingEdited) {
if(drawP.layerMan.is_a_layer_being_edited()) { if(drawP.layerMan.is_a_layer_being_edited()) {
isDrawing = true;
CanvasComponentContainer* newBrushStrokeContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::BRUSHSTROKE); CanvasComponentContainer* newBrushStrokeContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::BRUSHSTROKE);
BrushStrokeCanvasComponent& newBrushStroke = static_cast<BrushStrokeCanvasComponent&>(newBrushStrokeContainer->get_comp()); BrushStrokeCanvasComponent& newBrushStroke = static_cast<BrushStrokeCanvasComponent&>(newBrushStrokeContainer->get_comp());
@ -148,10 +145,8 @@ void BrushTool::tool_update() {
containerPtr->commit_update(drawP); containerPtr->commit_update(drawP);
} }
} }
else if(isDrawing) { else if(objInfoBeingEdited)
isDrawing = false;
commit_stroke(); commit_stroke();
}
} }
void BrushTool::commit_stroke() { void BrushTool::commit_stroke() {
@ -179,7 +174,7 @@ bool BrushTool::right_click_popup_gui(Vector2f popupPos) {
} }
bool BrushTool::prevent_undo_or_redo() { bool BrushTool::prevent_undo_or_redo() {
return isDrawing; return objInfoBeingEdited;
} }
void BrushTool::draw(SkCanvas* canvas, const DrawData& drawData) { void BrushTool::draw(SkCanvas* canvas, const DrawData& drawData) {
@ -189,7 +184,7 @@ void BrushTool::draw(SkCanvas* canvas, const DrawData& drawData) {
linePaint.setStroke(true); linePaint.setStroke(true);
linePaint.setStrokeWidth(0.0f); linePaint.setStrokeWidth(0.0f);
float width; float width;
if(isDrawing) if(objInfoBeingEdited)
width = drawP.controls.relativeWidth * penWidth * 0.5f; width = drawP.controls.relativeWidth * penWidth * 0.5f;
else else
width = drawP.controls.relativeWidth * 0.5f; width = drawP.controls.relativeWidth * 0.5f;

5
src/DrawingProgram/Tools/BrushTool.hpp
View file

@ -20,7 +20,7 @@ class BrushTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual void tool_update() override; virtual void tool_update() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
@ -37,8 +37,7 @@ class BrushTool : public DrawingProgramToolBase {
}; };
std::deque<SmoothingPoint> penSmoothingData; std::deque<SmoothingPoint> penSmoothingData;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited; CanvasComponentContainer::ObjInfo* objInfoBeingEdited = nullptr;
bool isDrawing = false;
bool hasRoundCaps = true; bool hasRoundCaps = true;
bool drawingMinimumRelativeToSize = true; bool drawingMinimumRelativeToSize = true;
bool midwayInterpolation = true; bool midwayInterpolation = true;

2
src/DrawingProgram/Tools/DrawingProgramToolBase.hpp
View file

@ -28,7 +28,7 @@ class DrawingProgramToolBase {
DrawingProgramToolBase(DrawingProgram& initDrawP); DrawingProgramToolBase(DrawingProgram& initDrawP);
virtual DrawingProgramToolType get_type() = 0; virtual DrawingProgramToolType get_type() = 0;
virtual void gui_toolbox() = 0; virtual void gui_toolbox() = 0;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) = 0; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) = 0;
virtual bool right_click_popup_gui(Vector2f popupPos) = 0; virtual bool right_click_popup_gui(Vector2f popupPos) = 0;
virtual void tool_update() = 0; virtual void tool_update() = 0;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0; virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;

27
src/DrawingProgram/Tools/EditTool.cpp
View file

@ -24,7 +24,7 @@ DrawingProgramToolType EditTool::get_type() {
void EditTool::gui_toolbox() { void EditTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
if(isEditing) { if(objInfoBeingEdited) {
bool editHappened = compEditTool->edit_gui(objInfoBeingEdited); bool editHappened = compEditTool->edit_gui(objInfoBeingEdited);
if(editHappened) if(editHappened)
objInfoBeingEdited->obj->commit_update(drawP); objInfoBeingEdited->obj->commit_update(drawP);
@ -36,13 +36,13 @@ void EditTool::gui_toolbox() {
} }
} }
void EditTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void EditTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(erasedComp == objInfoBeingEdited) if(erasedComp == objInfoBeingEdited)
switch_tool(get_type()); switch_tool(get_type());
} }
bool EditTool::right_click_popup_gui(Vector2f popupPos) { bool EditTool::right_click_popup_gui(Vector2f popupPos) {
if(isEditing) if(objInfoBeingEdited)
return compEditTool->right_click_popup_gui(objInfoBeingEdited, popupPos); return compEditTool->right_click_popup_gui(objInfoBeingEdited, popupPos);
else else
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
@ -61,14 +61,13 @@ void EditTool::switch_tool(DrawingProgramToolType newTool) {
} }
pointHandles.clear(); pointHandles.clear();
pointDragging = nullptr; pointDragging = nullptr;
isEditing = false;
if(!drawP.is_selection_allowing_tool(newTool)) if(!drawP.is_selection_allowing_tool(newTool))
drawP.selection.deselect_all(); drawP.selection.deselect_all();
} }
void EditTool::edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { void EditTool::edit_start(CanvasComponentContainer::ObjInfo* comp) {
isEditing = true; bool isEditing = true;
switch(comp->obj->get_comp().get_type()) { switch(comp->obj->get_comp().get_type()) {
case CanvasComponentType::TEXTBOX: { case CanvasComponentType::TEXTBOX: {
compEditTool = std::make_unique<TextBoxEditTool>(drawP); compEditTool = std::make_unique<TextBoxEditTool>(drawP);
@ -97,12 +96,12 @@ void EditTool::edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp
} }
} }
bool EditTool::is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool EditTool::is_editable(CanvasComponentContainer::ObjInfo* comp) {
return comp->obj->get_comp().get_type() != CanvasComponentType::BRUSHSTROKE; return comp->obj->get_comp().get_type() != CanvasComponentType::BRUSHSTROKE;
} }
void EditTool::tool_update() { void EditTool::tool_update() {
if(!isEditing) { if(!objInfoBeingEdited) {
SCollision::AABB<WorldScalar> mouseAABB{drawP.world.get_mouse_world_pos() - WorldVec{0.5f, 0.5f}, drawP.world.get_mouse_world_pos() + WorldVec{0.5f, 0.5f}}; SCollision::AABB<WorldScalar> mouseAABB{drawP.world.get_mouse_world_pos() - WorldVec{0.5f, 0.5f}, drawP.world.get_mouse_world_pos() + WorldVec{0.5f, 0.5f}};
SCollision::ColliderCollection<WorldScalar> cMouseAABB; SCollision::ColliderCollection<WorldScalar> cMouseAABB;
cMouseAABB.aabb.emplace_back(mouseAABB); cMouseAABB.aabb.emplace_back(mouseAABB);
@ -116,7 +115,7 @@ void EditTool::tool_update() {
if(drawP.controls.leftClick) { if(drawP.controls.leftClick) {
bool modifySelection = !drawP.selection.is_being_transformed(); bool modifySelection = !drawP.selection.is_being_transformed();
if(drawP.world.main.input.mouse.leftClicks >= 2 && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held) { if(drawP.world.main.input.mouse.leftClicks >= 2 && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held) {
CanvasComponentContainer::ObjInfoSharedPtr selectedObjectToEdit = drawP.selection.get_front_object_colliding_with_in_editing_layer(camCMouseAABB); CanvasComponentContainer::ObjInfo* selectedObjectToEdit = drawP.selection.get_front_object_colliding_with_in_editing_layer(camCMouseAABB);
if(selectedObjectToEdit && is_editable(selectedObjectToEdit)) { if(selectedObjectToEdit && is_editable(selectedObjectToEdit)) {
drawP.selection.deselect_all(); drawP.selection.deselect_all();
@ -181,14 +180,12 @@ void EditTool::tool_update() {
} }
bool EditTool::prevent_undo_or_redo() { bool EditTool::prevent_undo_or_redo() {
return isEditing; return objInfoBeingEdited;
} }
void EditTool::draw(SkCanvas* canvas, const DrawData& drawData) { void EditTool::draw(SkCanvas* canvas, const DrawData& drawData) {
if(isEditing) { if(objInfoBeingEdited) {
if(objInfoBeingEdited) { for(HandleData& h : pointHandles)
for(HandleData& h : pointHandles) drawP.draw_drag_circle(canvas, drawData.cam.c.to_space((objInfoBeingEdited->obj->coords.from_space(*h.p))), {0.1f, 0.9f, 0.9f, 1.0f}, drawData);
drawP.draw_drag_circle(canvas, drawData.cam.c.to_space((objInfoBeingEdited->obj->coords.from_space(*h.p))), {0.1f, 0.9f, 0.9f, 1.0f}, drawData);
}
} }
} }

9
src/DrawingProgram/Tools/EditTool.hpp
View file

@ -20,19 +20,18 @@ class EditTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
void add_point_handle(const HandleData& handle); void add_point_handle(const HandleData& handle);
void edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp); void edit_start(CanvasComponentContainer::ObjInfo* comp);
bool is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp); bool is_editable(CanvasComponentContainer::ObjInfo* comp);
std::unique_ptr<DrawingProgramEditToolBase> compEditTool; std::unique_ptr<DrawingProgramEditToolBase> compEditTool;
std::vector<HandleData> pointHandles; std::vector<HandleData> pointHandles;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited; CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
bool isEditing = false;
HandleData* pointDragging = nullptr; HandleData* pointDragging = nullptr;
std::any prevData; std::any prevData;
}; };

2
src/DrawingProgram/Tools/EditTools/DrawingProgramEditToolBase.cpp
View file

@ -5,7 +5,7 @@ DrawingProgramEditToolBase::DrawingProgramEditToolBase(DrawingProgram& initDrawP
drawP(initDrawP) drawP(initDrawP)
{} {}
bool DrawingProgramEditToolBase::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) { bool DrawingProgramEditToolBase::right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.paint_popup(popupPos); t.paint_popup(popupPos);
return true; return true;

10
src/DrawingProgram/Tools/EditTools/DrawingProgramEditToolBase.hpp
View file

@ -9,11 +9,11 @@ class EditTool;
class DrawingProgramEditToolBase { class DrawingProgramEditToolBase {
public: public:
DrawingProgramEditToolBase(DrawingProgram& initDrawP); DrawingProgramEditToolBase(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0; virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* compContainer, std::any& prevData) = 0;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0; virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* compContainer, std::any& prevData) = 0;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0; virtual bool edit_update(CanvasComponentContainer::ObjInfo* compContainer) = 0;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0; virtual bool edit_gui(CanvasComponentContainer::ObjInfo* compContainer) = 0;
virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos); virtual bool right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos);
virtual ~DrawingProgramEditToolBase(); virtual ~DrawingProgramEditToolBase();
protected: protected:
DrawingProgram& drawP; DrawingProgram& drawP;

8
src/DrawingProgram/Tools/EditTools/EllipseDrawEditTool.cpp
View file

@ -11,7 +11,7 @@ EllipseDrawEditTool::EllipseDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool EllipseDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool EllipseDrawEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
@ -42,7 +42,7 @@ bool EllipseDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoShared
return editHappened; return editHappened;
} }
void EllipseDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void EllipseDrawEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp());
prevData = a.d; prevData = a.d;
@ -50,9 +50,9 @@ void EllipseDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentCo
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr}); editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
} }
void EllipseDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void EllipseDrawEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
} }
bool EllipseDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool EllipseDrawEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true; return true;
} }

8
src/DrawingProgram/Tools/EditTools/EllipseDrawEditTool.hpp
View file

@ -10,10 +10,10 @@ class DrawingProgram;
class EllipseDrawEditTool : public DrawingProgramEditToolBase { class EllipseDrawEditTool : public DrawingProgramEditToolBase {
public: public:
EllipseDrawEditTool(DrawingProgram& initDrawP); EllipseDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
private: private:
void commit(); void commit();

8
src/DrawingProgram/Tools/EditTools/ImageEditTool.cpp
View file

@ -16,17 +16,17 @@ ImageEditTool::ImageEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
void ImageEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void ImageEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
} }
void ImageEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void ImageEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
} }
bool ImageEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool ImageEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true; return true;
} }
bool ImageEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool ImageEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
ImageCanvasComponent& a = static_cast<ImageCanvasComponent&>(comp->obj->get_comp()); ImageCanvasComponent& a = static_cast<ImageCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool image"); t.gui.push_id("edit tool image");

8
src/DrawingProgram/Tools/EditTools/ImageEditTool.hpp
View file

@ -7,8 +7,8 @@ class DrawingProgram;
class ImageEditTool : public DrawingProgramEditToolBase { class ImageEditTool : public DrawingProgramEditToolBase {
public: public:
ImageEditTool(DrawingProgram& initDrawP); ImageEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
}; };

8
src/DrawingProgram/Tools/EditTools/RectDrawEditTool.cpp
View file

@ -9,7 +9,7 @@ RectDrawEditTool::RectDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool RectDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool RectDrawEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool rectangle"); t.gui.push_id("edit tool rectangle");
@ -40,16 +40,16 @@ bool RectDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr
return editHappened; return editHappened;
} }
void RectDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void RectDrawEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp());
prevData = a.d; prevData = a.d;
editTool.add_point_handle({&a.d.p1, nullptr, &a.d.p2}); editTool.add_point_handle({&a.d.p1, nullptr, &a.d.p2});
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr}); editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
} }
void RectDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void RectDrawEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
} }
bool RectDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool RectDrawEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true; return true;
} }

8
src/DrawingProgram/Tools/EditTools/RectDrawEditTool.hpp
View file

@ -9,10 +9,10 @@ class DrawingProgram;
class RectDrawEditTool : public DrawingProgramEditToolBase { class RectDrawEditTool : public DrawingProgramEditToolBase {
public: public:
RectDrawEditTool(DrawingProgram& initDrawP); RectDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
private: private:
std::optional<RectangleCanvasComponent::Data> oldData; std::optional<RectangleCanvasComponent::Data> oldData;
}; };

10
src/DrawingProgram/Tools/EditTools/TextBoxEditTool.cpp
View file

@ -20,7 +20,7 @@ TextBoxEditTool::TextBoxEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool TextBoxEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool TextBoxEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
@ -152,7 +152,7 @@ bool TextBoxEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr&
return oldInputChangedTextBox; return oldInputChangedTextBox;
} }
bool TextBoxEditTool::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) { bool TextBoxEditTool::right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
bool shouldClose = false; bool shouldClose = false;
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
@ -250,7 +250,7 @@ void TextBoxEditTool::set_styles_at_selection(TextBoxCanvasComponent& a) {
currentPStyle = a.textBox->get_paragraph_style_data_at(start.fParagraphIndex); currentPStyle = a.textBox->get_paragraph_style_data_at(start.fParagraphIndex);
} }
void TextBoxEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void TextBoxEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
a.d.editing = false; a.d.editing = false;
comp->obj->commit_update(drawP); comp->obj->commit_update(drawP);
@ -263,7 +263,7 @@ TextBoxEditTool::TextBoxEditToolAllData TextBoxEditTool::get_all_data(const Text
}; };
} }
void TextBoxEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) { void TextBoxEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
auto& cur = a.cursor; auto& cur = a.cursor;
auto& textbox = a.textBox; auto& textbox = a.textBox;
@ -280,7 +280,7 @@ void TextBoxEditTool::edit_start(EditTool& editTool, const CanvasComponentContai
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr}); editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
} }
bool TextBoxEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) { bool TextBoxEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
SCollision::ColliderCollection<float> mousePointCollection; SCollision::ColliderCollection<float> mousePointCollection;

10
src/DrawingProgram/Tools/EditTools/TextBoxEditTool.hpp
View file

@ -10,11 +10,11 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
public: public:
TextBoxEditTool(DrawingProgram& initDrawP); TextBoxEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool,const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool,CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override; virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override; virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) override; virtual bool right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) override;
private: private:
struct TextBoxEditToolAllData { struct TextBoxEditToolAllData {
TextBoxCanvasComponent::Data textboxData; TextBoxCanvasComponent::Data textboxData;

75
src/DrawingProgram/Tools/EllipseDrawTool.cpp
View file

@ -29,11 +29,9 @@ void EllipseDrawTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void EllipseDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void EllipseDrawTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp) { if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr; objInfoBeingEdited = nullptr;
drawStage = 0;
}
} }
bool EllipseDrawTool::right_click_popup_gui(Vector2f popupPos) { bool EllipseDrawTool::right_click_popup_gui(Vector2f popupPos) {
@ -47,53 +45,46 @@ void EllipseDrawTool::switch_tool(DrawingProgramToolType newTool) {
} }
void EllipseDrawTool::tool_update() { void EllipseDrawTool::tool_update() {
switch(drawStage) { if(objInfoBeingEdited) {
case 0: { if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) { CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::ELLIPSE);
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::ELLIPSE); EllipseCanvasComponent& newEllipse = static_cast<EllipseCanvasComponent&>(newContainer->get_comp());
EllipseCanvasComponent& newEllipse = static_cast<EllipseCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos; startAt = drawP.world.main.input.mouse.pos;
newEllipse.d.strokeColor = drawP.controls.foregroundColor; newEllipse.d.strokeColor = drawP.controls.foregroundColor;
newEllipse.d.fillColor = drawP.controls.backgroundColor; newEllipse.d.fillColor = drawP.controls.backgroundColor;
newEllipse.d.strokeWidth = drawP.controls.relativeWidth; newEllipse.d.strokeWidth = drawP.controls.relativeWidth;
newEllipse.d.p1 = startAt; newEllipse.d.p1 = startAt;
newEllipse.d.p2 = startAt; newEllipse.d.p2 = startAt;
newEllipse.d.p2 = ensure_points_have_distance(newEllipse.d.p1, newEllipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); newEllipse.d.p2 = ensure_points_have_distance(newEllipse.d.p1, newEllipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newEllipse.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode); newEllipse.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c; newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer); objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
} }
case 1: { }
if(drawP.controls.leftClickHeld) { else {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj; if(drawP.controls.leftClickHeld) {
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) { Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
float height = std::fabs(startAt.y() - newPos.y()); if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height); float height = std::fabs(startAt.y() - newPos.y());
} newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
EllipseCanvasComponent& ellipse = static_cast<EllipseCanvasComponent&>(containerPtr->get_comp());
ellipse.d.p1 = cwise_vec_min(startAt, newPos);
ellipse.d.p2 = cwise_vec_max(startAt, newPos);
ellipse.d.p2 = ensure_points_have_distance(ellipse.d.p1, ellipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
} }
else { EllipseCanvasComponent& ellipse = static_cast<EllipseCanvasComponent&>(containerPtr->get_comp());
commit(); ellipse.d.p1 = cwise_vec_min(startAt, newPos);
drawStage = 0; ellipse.d.p2 = cwise_vec_max(startAt, newPos);
} ellipse.d.p2 = ensure_points_have_distance(ellipse.d.p1, ellipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
break; containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
} }
else
commit();
} }
} }
bool EllipseDrawTool::prevent_undo_or_redo() { bool EllipseDrawTool::prevent_undo_or_redo() {
return (drawStage == 1); return objInfoBeingEdited;
} }
void EllipseDrawTool::commit() { void EllipseDrawTool::commit() {

5
src/DrawingProgram/Tools/EllipseDrawTool.hpp
View file

@ -12,7 +12,7 @@ class EllipseDrawTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
@ -22,6 +22,5 @@ class EllipseDrawTool : public DrawingProgramToolBase {
Vector2f startAt; Vector2f startAt;
int fillStrokeMode = 1; int fillStrokeMode = 1;
int drawStage = 0; CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
}; };

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

@ -31,7 +31,7 @@ bool EraserTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void EraserTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void EraserTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
erasedComponents.erase(erasedComp); erasedComponents.erase(erasedComp);
} }
@ -57,7 +57,7 @@ void EraserTool::tool_update() {
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) { SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) {
drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds); drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds);
drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) { drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto& c) { drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) { if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
erasedComponents.emplace(c); erasedComponents.emplace(c);
return true; return true;
@ -68,7 +68,7 @@ void EraserTool::tool_update() {
}); });
return false; return false;
} }
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto& c) { drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) { if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
erasedComponents.emplace(c); erasedComponents.emplace(c);
drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds()); drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());

4
src/DrawingProgram/Tools/EraserTool.hpp
View file

@ -12,11 +12,11 @@ class EraserTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> erasedComponents; // Pointers will be erased from this set if theyre erased in the main list (done by callback) std::unordered_set<CanvasComponentContainer::ObjInfo*> erasedComponents; // Pointers will be erased from this set if theyre erased in the main list (done by callback)
}; };

2
src/DrawingProgram/Tools/EyeDropperTool.cpp
View file

@ -44,7 +44,7 @@ bool EyeDropperTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void EyeDropperTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void EyeDropperTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void EyeDropperTool::tool_update() { void EyeDropperTool::tool_update() {

2
src/DrawingProgram/Tools/EyeDropperTool.hpp
View file

@ -10,7 +10,7 @@ class EyeDropperTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/GridModifyTool.cpp
View file

@ -33,7 +33,7 @@ DrawingProgramToolType GridModifyTool::get_type() {
return DrawingProgramToolType::GRIDMODIFY; return DrawingProgramToolType::GRIDMODIFY;
} }
void GridModifyTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void GridModifyTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void GridModifyTool::gui_toolbox() { void GridModifyTool::gui_toolbox() {

2
src/DrawingProgram/Tools/GridModifyTool.hpp
View file

@ -13,7 +13,7 @@ class GridModifyTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/LassoSelectTool.cpp
View file

@ -54,7 +54,7 @@ bool LassoSelectTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
} }
void LassoSelectTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void LassoSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void LassoSelectTool::switch_tool(DrawingProgramToolType newTool) { void LassoSelectTool::switch_tool(DrawingProgramToolType newTool) {

2
src/DrawingProgram/Tools/LassoSelectTool.hpp
View file

@ -13,7 +13,7 @@ class LassoSelectTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/PanCanvasTool.cpp
View file

@ -25,7 +25,7 @@ bool PanCanvasTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
} }
void PanCanvasTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void PanCanvasTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void PanCanvasTool::tool_update() { void PanCanvasTool::tool_update() {

2
src/DrawingProgram/Tools/PanCanvasTool.hpp
View file

@ -9,7 +9,7 @@ class PanCanvasTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;

78
src/DrawingProgram/Tools/RectDrawTool.cpp
View file

@ -27,11 +27,9 @@ void RectDrawTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void RectDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void RectDrawTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp) { if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr; objInfoBeingEdited = nullptr;
drawStage = 0;
}
} }
bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) { bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
@ -42,57 +40,49 @@ bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
void RectDrawTool::switch_tool(DrawingProgramToolType newTool) { void RectDrawTool::switch_tool(DrawingProgramToolType newTool) {
commit(); commit();
drawStage = 0;
} }
void RectDrawTool::tool_update() { void RectDrawTool::tool_update() {
switch(drawStage) { if(objInfoBeingEdited) {
case 0: { if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) { CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::RECTANGLE);
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::RECTANGLE); RectangleCanvasComponent& newRectangle = static_cast<RectangleCanvasComponent&>(newContainer->get_comp());
RectangleCanvasComponent& newRectangle = static_cast<RectangleCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos; startAt = drawP.world.main.input.mouse.pos;
newRectangle.d.strokeColor = drawP.controls.foregroundColor; newRectangle.d.strokeColor = drawP.controls.foregroundColor;
newRectangle.d.fillColor = drawP.controls.backgroundColor; newRectangle.d.fillColor = drawP.controls.backgroundColor;
newRectangle.d.cornerRadius = relativeRadiusWidth; newRectangle.d.cornerRadius = relativeRadiusWidth;
newRectangle.d.strokeWidth = drawP.controls.relativeWidth; newRectangle.d.strokeWidth = drawP.controls.relativeWidth;
newRectangle.d.p1 = startAt; newRectangle.d.p1 = startAt;
newRectangle.d.p2 = startAt; newRectangle.d.p2 = startAt;
newRectangle.d.p2 = ensure_points_have_distance(newRectangle.d.p1, newRectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); newRectangle.d.p2 = ensure_points_have_distance(newRectangle.d.p1, newRectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newRectangle.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode); newRectangle.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c; newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer); objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
} }
case 1: { }
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj; else {
if(drawP.controls.leftClickHeld) { NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world); if(drawP.controls.leftClickHeld) {
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) { Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
float height = std::fabs(startAt.y() - newPos.y()); if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height); float height = std::fabs(startAt.y() - newPos.y());
} newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
RectangleCanvasComponent& rectangle = static_cast<RectangleCanvasComponent&>(containerPtr->get_comp());
rectangle.d.p1 = cwise_vec_min(startAt, newPos);
rectangle.d.p2 = cwise_vec_max(startAt, newPos);
rectangle.d.p2 = ensure_points_have_distance(rectangle.d.p1, rectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
} }
else { RectangleCanvasComponent& rectangle = static_cast<RectangleCanvasComponent&>(containerPtr->get_comp());
commit(); rectangle.d.p1 = cwise_vec_min(startAt, newPos);
drawStage = 0; rectangle.d.p2 = cwise_vec_max(startAt, newPos);
} rectangle.d.p2 = ensure_points_have_distance(rectangle.d.p1, rectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
break; containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
} }
else
commit();
} }
} }
bool RectDrawTool::prevent_undo_or_redo() { bool RectDrawTool::prevent_undo_or_redo() {
return (drawStage == 1); return objInfoBeingEdited;
} }
void RectDrawTool::commit() { void RectDrawTool::commit() {

5
src/DrawingProgram/Tools/RectDrawTool.hpp
View file

@ -11,7 +11,7 @@ class RectDrawTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
@ -22,6 +22,5 @@ class RectDrawTool : public DrawingProgramToolBase {
Vector2f startAt; Vector2f startAt;
float relativeRadiusWidth = 10.0f; float relativeRadiusWidth = 10.0f;
int fillStrokeMode = 1; int fillStrokeMode = 1;
int drawStage = 0; CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
}; };

2
src/DrawingProgram/Tools/RectSelectTool.cpp
View file

@ -28,7 +28,7 @@ void RectSelectTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void RectSelectTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void RectSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
bool RectSelectTool::right_click_popup_gui(Vector2f popupPos) { bool RectSelectTool::right_click_popup_gui(Vector2f popupPos) {

2
src/DrawingProgram/Tools/RectSelectTool.hpp
View file

@ -10,7 +10,7 @@ class RectSelectTool : public DrawingProgramToolBase {
RectSelectTool(DrawingProgram& initDrawP); RectSelectTool(DrawingProgram& initDrawP);
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;

2
src/DrawingProgram/Tools/ScreenshotTool.cpp
View file

@ -116,7 +116,7 @@ bool ScreenshotTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void ScreenshotTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void ScreenshotTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void ScreenshotTool::take_screenshot(const std::filesystem::path& filePath) { void ScreenshotTool::take_screenshot(const std::filesystem::path& filePath) {

2
src/DrawingProgram/Tools/ScreenshotTool.hpp
View file

@ -13,7 +13,7 @@ class ScreenshotTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;

80
src/DrawingProgram/Tools/TextBoxTool.cpp
View file

@ -26,11 +26,9 @@ void TextBoxTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void TextBoxTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void TextBoxTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp) { if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr; objInfoBeingEdited = nullptr;
drawStage = 0;
}
} }
bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) { bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
@ -41,58 +39,52 @@ bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
void TextBoxTool::switch_tool(DrawingProgramToolType newTool) { void TextBoxTool::switch_tool(DrawingProgramToolType newTool) {
commit(); commit();
drawStage = 0;
} }
void TextBoxTool::tool_update() { void TextBoxTool::tool_update() {
switch(drawStage) { if(objInfoBeingEdited) {
case 0: { if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) { startAt = drawP.world.main.input.mouse.pos;
startAt = drawP.world.main.input.mouse.pos; endAt = startAt;
endAt = startAt;
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::TEXTBOX); CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::TEXTBOX);
TextBoxCanvasComponent& newTextBox = static_cast<TextBoxCanvasComponent&>(newContainer->get_comp()); TextBoxCanvasComponent& newTextBox = static_cast<TextBoxCanvasComponent&>(newContainer->get_comp());
newTextBox.d.p1 = newTextBox.d.p2 = startAt; newTextBox.d.p1 = newTextBox.d.p2 = startAt;
newTextBox.d.p2 = ensure_points_have_distance(newTextBox.d.p1, newTextBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); newTextBox.d.p2 = ensure_points_have_distance(newTextBox.d.p1, newTextBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newTextBox.d.editing = true; newTextBox.d.editing = true;
newContainer->coords = drawP.world.drawData.cam.c; newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer); objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
} }
case 1: { }
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj; else {
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp()); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp());
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world); Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) { if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y()); float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height); newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
} }
endAt = newPos; endAt = newPos;
textBox.d.p1 = cwise_vec_min(endAt, startAt); textBox.d.p1 = cwise_vec_min(endAt, startAt);
textBox.d.p2 = cwise_vec_max(endAt, startAt); textBox.d.p2 = cwise_vec_max(endAt, startAt);
textBox.d.p2 = ensure_points_have_distance(textBox.d.p1, textBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); textBox.d.p2 = ensure_points_have_distance(textBox.d.p1, textBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
if(!drawP.controls.leftClickHeld) { if(!drawP.controls.leftClickHeld) {
auto editTool = std::make_unique<EditTool>(drawP); auto editTool = std::make_unique<EditTool>(drawP);
editTool->edit_start(objInfoBeingEdited); editTool->edit_start(objInfoBeingEdited);
drawP.toolToSwitchToAfterUpdate = std::move(editTool); drawP.toolToSwitchToAfterUpdate = std::move(editTool);
return; return;
} }
else { else {
containerPtr->send_comp_update(drawP, false); containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP); containerPtr->commit_update(drawP);
}
break;
} }
} }
} }
bool TextBoxTool::prevent_undo_or_redo() { bool TextBoxTool::prevent_undo_or_redo() {
return (drawStage == 1); return objInfoBeingEdited;
} }
void TextBoxTool::commit() { void TextBoxTool::commit() {

4
src/DrawingProgram/Tools/TextBoxTool.hpp
View file

@ -11,7 +11,7 @@ class TextBoxTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
@ -22,5 +22,5 @@ class TextBoxTool : public DrawingProgramToolBase {
Vector2f startAt; Vector2f startAt;
Vector2f endAt; Vector2f endAt;
int drawStage = 0; int drawStage = 0;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited; CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
}; };

2
src/DrawingProgram/Tools/ZoomCanvasTool.cpp
View file

@ -25,7 +25,7 @@ bool ZoomCanvasTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
} }
void ZoomCanvasTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) { void ZoomCanvasTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
} }
void ZoomCanvasTool::tool_update() { void ZoomCanvasTool::tool_update() {

2
src/DrawingProgram/Tools/ZoomCanvasTool.hpp
View file

@ -9,7 +9,7 @@ class ZoomCanvasTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override; virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override; virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override; virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override; virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override; virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;

2
src/GridManager.cpp
View file

@ -23,7 +23,7 @@ void GridManager::add_default_grid(const std::string& newName) {
void GridManager::remove_grid(uint32_t indexToRemove) { void GridManager::remove_grid(uint32_t indexToRemove) {
if(grids) if(grids)
grids->erase(grids, indexToRemove); grids->erase(grids, grids->at(indexToRemove));
} }
void GridManager::draw_back(SkCanvas* canvas, const DrawData& drawData) { void GridManager::draw_back(SkCanvas* canvas, const DrawData& drawData) {