All tools now converted to use new net objects

This commit is contained in:
Yousef Khadadeh 2025-12-15 15:36:42 +03:00
parent 45ba26446a
commit 7d1671229b
62 changed files with 492 additions and 481 deletions

View file

@ -11,13 +11,13 @@ namespace NetworkingObjects {
std::function<void(const T& o, cereal::PortableBinaryOutputArchive& a)> writeConstructor = [](const T& o, cereal::PortableBinaryOutputArchive& a) { std::function<void(const T& o, cereal::PortableBinaryOutputArchive& a)> writeConstructor = [](const T& o, cereal::PortableBinaryOutputArchive& a) {
a(o); a(o);
}; };
std::function<void(T& o, cereal::PortableBinaryOutputArchive& a)> readConstructor = [](T& o, cereal::PortableBinaryOutputArchive& a) { std::function<void(T& o, cereal::PortableBinaryInputArchive& a)> readConstructor = [](T& o, cereal::PortableBinaryInputArchive& a) {
a(o); a(o);
}; };
std::function<void(const T& o, cereal::PortableBinaryOutputArchive& a)> writeUpdate = [](const T& o, cereal::PortableBinaryOutputArchive& a) { std::function<void(const T& o, cereal::PortableBinaryOutputArchive& a)> writeUpdate = [](const T& o, cereal::PortableBinaryOutputArchive& a) {
a(o); a(o);
}; };
std::function<void(T& o, cereal::PortableBinaryOutputArchive& a)> readUpdate = [](T& o, cereal::PortableBinaryOutputArchive& a) { std::function<void(T& o, cereal::PortableBinaryInputArchive& a)> readUpdate = [](T& o, cereal::PortableBinaryInputArchive& a) {
a(o); a(o);
}; };
std::function<std::shared_ptr<T>(const T& o)> allocateCopy = [](const T& o) { std::function<std::shared_ptr<T>(const T& o)> allocateCopy = [](const T& o) {
@ -34,11 +34,11 @@ namespace NetworkingObjects {
}; };
template <typename T> void register_class(NetObjManager& objMan, const CustomConstructors<T>& t = CustomConstructors<T>()) { template <typename T> void register_class(NetObjManager& objMan, const CustomConstructors<T>& t = CustomConstructors<T>()) {
objMan.register_class<T, T, T, T>({ objMan.register_class<T, T, T, T>({
.writeConstructorFuncClient = t.writeConstructor, .writeConstructorFuncClient = [writeConstructor = t.writeConstructor](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a) {writeConstructor(*o, a);},
.readConstructorFuncClient = t.readConstructor, .readConstructorFuncClient = [readConstructor = t.readConstructor](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) {readConstructor(*o, a);},
.readUpdateFuncClient = [&, readUpdate = t.readUpdate](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&){client_read_update_func<T>(o, a, readUpdate);}, .readUpdateFuncClient = [&, readUpdate = t.readUpdate](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&){client_read_update_func<T>(o, a, readUpdate);},
.writeConstructorFuncServer = t.writeConstructor, .writeConstructorFuncServer = [writeConstructor = t.writeConstructor](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a) {writeConstructor(*o, a);},
.readConstructorFuncServer = t.readConstructor, .readConstructorFuncServer = [readConstructor = t.readConstructor](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) {readConstructor(*o, a);},
.readUpdateFuncServer = [&, readUpdate = t.readUpdate](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&){server_read_update_func<T>(o, a, readUpdate);} .readUpdateFuncServer = [&, readUpdate = t.readUpdate](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&){server_read_update_func<T>(o, a, readUpdate);}
}); });
typeIndexFuncs[std::type_index(typeid(T))] = { typeIndexFuncs[std::type_index(typeid(T))] = {
@ -57,6 +57,7 @@ namespace NetworkingObjects {
}; };
} }
template <typename T> void send_update_to_all(const NetworkingObjects::NetObjTemporaryPtr<T>& o, bool finalUpdate) { template <typename T> void send_update_to_all(const NetworkingObjects::NetObjTemporaryPtr<T>& o, bool finalUpdate) {
// TODO: When finalUpdate = false, maybe add a small delay between updates instead of sending them every frame?
o.send_update_to_all(finalUpdate ? RELIABLE_COMMAND_CHANNEL : UNRELIABLE_COMMAND_CHANNEL, [&](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a) { o.send_update_to_all(finalUpdate ? RELIABLE_COMMAND_CHANNEL : UNRELIABLE_COMMAND_CHANNEL, [&](const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a) {
if(o.get_obj_man()->is_server()) if(o.get_obj_man()->is_server())
server_write_func(o, a); server_write_func(o, a);
@ -91,7 +92,7 @@ namespace NetworkingObjects {
} }
} }
template <typename T> void client_read_update_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::function<void(T&, cereal::PortableBinaryOutputArchive&)>& readUpdate) { template <typename T> void client_read_update_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::function<void(T&, cereal::PortableBinaryInputArchive&)>& readUpdate) {
auto it = updatingObjs.find(o.get_net_id()); auto it = updatingObjs.find(o.get_net_id());
if(it == updatingObjs.end()) { if(it == updatingObjs.end()) {
readUpdate(*o, a); readUpdate(*o, a);
@ -104,7 +105,7 @@ namespace NetworkingObjects {
} }
} }
template <typename T> void server_write_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a, const std::function<void(T&)>& postAssignmentFunc) { template <typename T> void server_write_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryOutputArchive& a) {
typeIndexFuncs[std::type_index(typeid(T))].writeUpdateFunc(static_cast<const void*>(o.get()), a); typeIndexFuncs[std::type_index(typeid(T))].writeUpdateFunc(static_cast<const void*>(o.get()), a);
auto it = updatingObjs.find(o.get_net_id()); auto it = updatingObjs.find(o.get_net_id());
@ -113,7 +114,7 @@ namespace NetworkingObjects {
toAdd.objToUpdateCurrentData = typeIndexFuncs[std::type_index(typeid(T))].allocateCopyFunc(static_cast<const void*>(o.get())); toAdd.objToUpdateCurrentData = typeIndexFuncs[std::type_index(typeid(T))].allocateCopyFunc(static_cast<const void*>(o.get()));
toAdd.lastUpdateTimePoint = std::chrono::steady_clock::now(); toAdd.lastUpdateTimePoint = std::chrono::steady_clock::now();
toAdd.doLastAssignment = std::make_shared<bool>(false); toAdd.doLastAssignment = std::make_shared<bool>(false);
toAdd.setDataAfterTimeout = [&typeIndexFuncs = typeIndexFuncs, postAssignmentFunc, oWeak = NetObjWeakPtr<T>(o), currentData = toAdd.objToUpdateCurrentData, doLastAssignment = toAdd.doLastAssignment]() { toAdd.setDataAfterTimeout = [&typeIndexFuncs = typeIndexFuncs, oWeak = NetObjWeakPtr<T>(o), currentData = toAdd.objToUpdateCurrentData, doLastAssignment = toAdd.doLastAssignment]() {
NetObjTemporaryPtr<T> oLock = oWeak.lock(); NetObjTemporaryPtr<T> oLock = oWeak.lock();
if(oLock && *doLastAssignment) { if(oLock && *doLastAssignment) {
typeIndexFuncs[std::type_index(typeid(T))].assignmentFunc(static_cast<void*>(oLock.get()), static_cast<const void*>(currentData.get())); typeIndexFuncs[std::type_index(typeid(T))].assignmentFunc(static_cast<void*>(oLock.get()), static_cast<const void*>(currentData.get()));
@ -133,7 +134,7 @@ namespace NetworkingObjects {
} }
} }
template <typename T> void server_read_update_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::function<void(T&, cereal::PortableBinaryOutputArchive&)>& readUpdate) { template <typename T> void server_read_update_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::function<void(T&, cereal::PortableBinaryInputArchive&)>& readUpdate) {
auto it = updatingObjs.find(o.get_net_id()); auto it = updatingObjs.find(o.get_net_id());
bool finalUpdate; bool finalUpdate;
if(it == updatingObjs.end()) { if(it == updatingObjs.end()) {

View file

@ -49,7 +49,7 @@ namespace NetworkingObjects {
template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct(Args&&... items) { template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct(Args&&... items) {
return emplace_raw_ptr<T>(NetObjID::random_gen(), new T(items...)); return emplace_raw_ptr<T>(NetObjID::random_gen(), new T(items...));
} }
template <typename T> NetObjOwnerPtr<T> obj_from_ptr(T* p) { template <typename T> NetObjOwnerPtr<T> make_obj_from_ptr(T* p) {
return emplace_raw_ptr<T>(NetObjID::random_gen(), p); return emplace_raw_ptr<T>(NetObjID::random_gen(), p);
} }
template <typename T> NetObjOwnerPtr<T> get_obj_ref_from_id(NetObjID id) { template <typename T> NetObjOwnerPtr<T> get_obj_ref_from_id(NetObjID id) {

View file

@ -53,11 +53,11 @@ namespace NetworkingObjects {
return l->insert(l, nullptr, l->size(), std::move(newObj)); return l->insert(l, nullptr, l->size(), std::move(newObj));
} }
static NetObjOrderedListObjectInfoPtr<T> push_back_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, T* newObj) { static NetObjOrderedListObjectInfoPtr<T> push_back_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, T* newObj) {
NetObjOwnerPtr<T> newObjOwner = l.get_obj_man()->template make_obj<T>(newObj); NetObjOwnerPtr<T> newObjOwner = l.get_obj_man()->template make_obj_from_ptr<T>(newObj);
return l->insert(l, nullptr, l->size(), std::move(newObjOwner)); return l->insert(l, nullptr, l->size(), std::move(newObjOwner));
} }
static NetObjOrderedListObjectInfoPtr<T> insert_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, uint32_t posToInsertAt, T* newObj) { static NetObjOrderedListObjectInfoPtr<T> insert_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, uint32_t posToInsertAt, T* newObj) {
NetObjOwnerPtr<T> newObjOwner = l.get_obj_man()->template make_obj<T>(newObj); NetObjOwnerPtr<T> newObjOwner = l.get_obj_man()->template make_obj_from_ptr<T>(newObj);
return l->insert(l, nullptr, posToInsertAt, std::move(newObjOwner)); return l->insert(l, nullptr, posToInsertAt, std::move(newObjOwner));
} }
static std::vector<NetObjOrderedListObjectInfoPtr<T>> insert_ordered_list_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, const std::vector<std::pair<uint32_t, T*>>& newObjs) { static std::vector<NetObjOrderedListObjectInfoPtr<T>> insert_ordered_list_and_send_create(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, const std::vector<std::pair<uint32_t, T*>>& newObjs) {
@ -65,7 +65,7 @@ namespace NetworkingObjects {
return {}; return {};
std::vector<std::pair<uint32_t, NetObjOwnerPtr<T>>> ownerPtrOrderedList; std::vector<std::pair<uint32_t, NetObjOwnerPtr<T>>> ownerPtrOrderedList;
for(uint32_t i = 0; i < static_cast<uint32_t>(newObjs.size()); i++) for(uint32_t i = 0; i < static_cast<uint32_t>(newObjs.size()); i++)
ownerPtrOrderedList.emplace_back(newObjs[i].first, std::move(l.get_obj_man()->template make_obj<T>(newObjs[i].second))); ownerPtrOrderedList.emplace_back(newObjs[i].first, std::move(l.get_obj_man()->template make_obj_from_ptr<T>(newObjs[i].second)));
return l->insert_ordered_list(l, nullptr, ownerPtrOrderedList); return l->insert_ordered_list(l, nullptr, ownerPtrOrderedList);
} }
static void erase_unordered_set(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, const std::unordered_set<NetObjID>& ids) { static void erase_unordered_set(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, const std::unordered_set<NetObjID>& ids) {

View file

@ -29,8 +29,8 @@ void BrushStrokeCanvasComponent::load_file(cereal::PortableBinaryInputArchive& a
a(d->points, d->color, d->hasRoundCaps); a(d->points, d->color, d->hasRoundCaps);
} }
CanvasComponent::CompType BrushStrokeCanvasComponent::get_type() const { CanvasComponentType BrushStrokeCanvasComponent::get_type() const {
return CompType::BRUSHSTROKE; return CanvasComponentType::BRUSHSTROKE;
} }
void BrushStrokeCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const { void BrushStrokeCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const {
@ -46,6 +46,11 @@ void BrushStrokeCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData
canvas->restore(); canvas->restore();
} }
void BrushStrokeCanvasComponent::set_data_from(const CanvasComponent& other) {
auto& otherStroke = static_cast<const BrushStrokeCanvasComponent&>(other);
d = otherStroke.d;
}
void BrushStrokeCanvasComponent::initialize_draw_data(DrawingProgram& drawP) { void BrushStrokeCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
if(!d->points.empty()) { if(!d->points.empty()) {
std::vector<BrushStrokeCanvasComponentPoint> points = smooth_points(0, d->points.size() - 1, DEFAULT_SMOOTHNESS); std::vector<BrushStrokeCanvasComponentPoint> points = smooth_points(0, d->points.size() - 1, DEFAULT_SMOOTHNESS);

View file

@ -17,7 +17,7 @@ class BrushStrokeCanvasComponent : public CanvasComponent {
public: public:
constexpr static float DRAW_MINIMUM_LIMIT = 0.3; constexpr static float DRAW_MINIMUM_LIMIT = 0.3;
virtual CompType get_type() const override; virtual CanvasComponentType get_type() const override;
virtual void save(cereal::PortableBinaryOutputArchive& a) const override; virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load(cereal::PortableBinaryInputArchive& a) override; virtual void load(cereal::PortableBinaryInputArchive& a) override;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
@ -30,6 +30,7 @@ class BrushStrokeCanvasComponent : public CanvasComponent {
}; };
std::shared_ptr<Data> d = std::make_shared<Data>(); // It's a pointer here since brush strokes cant be edited std::shared_ptr<Data> d = std::make_shared<Data>(); // It's a pointer here since brush strokes cant be edited
virtual void set_data_from(const CanvasComponent& other) override;
private: private:
virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override;
virtual void initialize_draw_data(DrawingProgram& drawP) override; virtual void initialize_draw_data(DrawingProgram& drawP) override;

View file

@ -8,17 +8,17 @@
void CanvasComponent::update(DrawingProgram& drawP) { void CanvasComponent::update(DrawingProgram& drawP) {
} }
CanvasComponent* CanvasComponent::allocate_comp(CanvasComponent::CompType type) { CanvasComponent* CanvasComponent::allocate_comp(CanvasComponentType type) {
switch(type) { switch(type) {
case CanvasComponent::CompType::BRUSHSTROKE: case CanvasComponentType::BRUSHSTROKE:
return new BrushStrokeCanvasComponent; return new BrushStrokeCanvasComponent;
case CanvasComponent::CompType::RECTANGLE: case CanvasComponentType::RECTANGLE:
return new RectangleCanvasComponent; return new RectangleCanvasComponent;
case CanvasComponent::CompType::ELLIPSE: case CanvasComponentType::ELLIPSE:
return new EllipseCanvasComponent; return new EllipseCanvasComponent;
case CanvasComponent::CompType::TEXTBOX: case CanvasComponentType::TEXTBOX:
return new TextBoxCanvasComponent; return new TextBoxCanvasComponent;
case CanvasComponent::CompType::IMAGE: case CanvasComponentType::IMAGE:
return new ImageCanvasComponent; return new ImageCanvasComponent;
} }
return nullptr; return nullptr;

View file

@ -4,28 +4,22 @@
#include <Helpers/VersionNumber.hpp> #include <Helpers/VersionNumber.hpp>
#include <include/core/SkCanvas.h> #include <include/core/SkCanvas.h>
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include "CanvasComponentType.hpp"
#include "CanvasComponentContainer.hpp"
class DrawingProgram; class DrawingProgram;
class DrawData;
class CanvasComponentContainer;
class CanvasComponent { class CanvasComponent {
public: public:
enum class CompType : uint8_t { virtual CanvasComponentType get_type() const = 0;
BRUSHSTROKE = 0,
RECTANGLE,
ELLIPSE,
TEXTBOX,
IMAGE
};
virtual CompType get_type() const = 0;
virtual ~CanvasComponent(); virtual ~CanvasComponent();
static CanvasComponent* allocate_comp(CanvasComponent::CompType type); static CanvasComponent* allocate_comp(CanvasComponentType type);
virtual void save(cereal::PortableBinaryOutputArchive& a) const = 0; virtual void save(cereal::PortableBinaryOutputArchive& a) const = 0;
virtual void load(cereal::PortableBinaryInputArchive& a) = 0; virtual void load(cereal::PortableBinaryInputArchive& a) = 0;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const = 0; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const = 0;
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) = 0; virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) = 0;
virtual void set_data_from(const CanvasComponent& other) = 0;
protected: protected:
friend class CanvasComponentContainer; friend class CanvasComponentContainer;
friend class CanvasComponentAllocator; friend class CanvasComponentAllocator;

View file

@ -1,21 +1,24 @@
#include "CanvasComponentAllocator.hpp" #include "CanvasComponentAllocator.hpp"
#include "CanvasComponentContainer.hpp" #include "CanvasComponentContainer.hpp"
#include "../DrawingProgram/DrawingProgram.hpp" #include "../DrawingProgram/DrawingProgram.hpp"
#include "../World.hpp"
#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
#include "CanvasComponent.hpp"
CanvasComponentAllocator::CanvasComponentAllocator() {} CanvasComponentAllocator::CanvasComponentAllocator() {}
CanvasComponentAllocator::CanvasComponentAllocator(CanvasComponent::CompType typeToAllocate) { CanvasComponentAllocator::CanvasComponentAllocator(CanvasComponentType typeToAllocate) {
comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate)); comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
} }
void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan) { void CanvasComponentAllocator::register_class(World& world, NetworkingObjects::NetObjManager& objMan) {
delayUpdateMan.register_class<CanvasComponentAllocator>(objMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<CanvasComponentAllocator>{ world.delayedUpdateObjectManager.register_class<CanvasComponentAllocator>(objMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<CanvasComponentAllocator>{
.writeConstructor = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) { .writeConstructor = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
a(o.comp->get_type()); a(o.comp->get_type());
a(*o.comp); a(*o.comp);
}, },
.readConstructor = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) { .readConstructor = [](CanvasComponentAllocator& o, cereal::PortableBinaryInputArchive& a) {
CanvasComponent::CompType typeToAllocate; CanvasComponentType typeToAllocate;
a(typeToAllocate); a(typeToAllocate);
o.comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate)); o.comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
a(*o.comp); a(*o.comp);
@ -23,7 +26,7 @@ void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingO
.writeUpdate = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) { .writeUpdate = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
a(*o.comp); a(*o.comp);
}, },
.readUpdate = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) { .readUpdate = [](CanvasComponentAllocator& o, cereal::PortableBinaryInputArchive& a) {
a(*o.comp); a(*o.comp);
}, },
.allocateCopy = [](const CanvasComponentAllocator& o) { .allocateCopy = [](const CanvasComponentAllocator& o) {
@ -33,9 +36,9 @@ void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingO
return theCopy; return theCopy;
}, },
.assignmentFunc = [](CanvasComponentAllocator& o, const CanvasComponentAllocator& o2) { .assignmentFunc = [](CanvasComponentAllocator& o, const CanvasComponentAllocator& o2) {
// Assignment still needs to be implemented o.comp->set_data_from(*o2.comp);
}, },
.postUpdateFunc = [&drawP](CanvasComponentAllocator& o) { .postUpdateFunc = [&drawP = world.drawProg](CanvasComponentAllocator& o) {
o.comp->compContainer->commit_update(drawP); o.comp->compContainer->commit_update(drawP);
} }
}); });

View file

@ -1,15 +1,16 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include "CanvasComponent.hpp" #include "CanvasComponentType.hpp"
#include <Helpers/NetworkingObjects/NetObjTemporaryPtr.hpp> #include <Helpers/NetworkingObjects/NetObjTemporaryPtr.hpp>
#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp> #include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
class DrawingProgram; class World;
class CanvasComponent;
class CanvasComponentAllocator { class CanvasComponentAllocator {
public: public:
CanvasComponentAllocator(); CanvasComponentAllocator();
CanvasComponentAllocator(CanvasComponent::CompType typeToAllocate); CanvasComponentAllocator(CanvasComponentType typeToAllocate);
std::unique_ptr<CanvasComponent> comp; std::unique_ptr<CanvasComponent> comp;
static void register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan); static void register_class(World& world, NetworkingObjects::NetObjManager& objMan);
}; };

View file

@ -3,13 +3,14 @@
#include "../DrawData.hpp" #include "../DrawData.hpp"
#include "../DrawingProgram/DrawingProgram.hpp" #include "../DrawingProgram/DrawingProgram.hpp"
#include "../World.hpp" #include "../World.hpp"
#include "CanvasComponent.hpp"
#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp> #include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
using namespace NetworkingObjects; using namespace NetworkingObjects;
CanvasComponentContainer::CanvasComponentContainer() { } CanvasComponentContainer::CanvasComponentContainer() { }
CanvasComponentContainer::CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponent::CompType type) { CanvasComponentContainer::CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponentType type) {
compAllocator = objMan.make_obj_direct<CanvasComponentAllocator>(type); compAllocator = objMan.make_obj_direct<CanvasComponentAllocator>(type);
} }

View file

@ -1,13 +1,13 @@
#pragma once #pragma once
#include "../CoordSpaceHelper.hpp" #include "../CoordSpaceHelper.hpp"
#include "CanvasComponent.hpp"
#include <Helpers/NetworkingObjects/NetObjManagerTypeList.hpp> #include <Helpers/NetworkingObjects/NetObjManagerTypeList.hpp>
#include "CanvasComponentType.hpp"
#include "../VersionConstants.hpp" #include "../VersionConstants.hpp"
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp> #include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include <Helpers/NetworkingObjects/NetObjOwnerPtr.hpp> #include <Helpers/NetworkingObjects/NetObjOwnerPtr.hpp>
#include "CanvasComponentAllocator.hpp"
class DrawingProgram; class DrawingProgram;
class CanvasComponentAllocator;
class DrawingProgramCacheBVHNode; class DrawingProgramCacheBVHNode;
class CanvasComponentContainer { class CanvasComponentContainer {
@ -26,7 +26,7 @@ class CanvasComponentContainer {
constexpr static int COMP_MIPMAP_LEVEL_TWO = 5; constexpr static int COMP_MIPMAP_LEVEL_TWO = 5;
CanvasComponentContainer(); CanvasComponentContainer();
CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponent::CompType type); CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponentType type);
static void register_class(NetworkingObjects::NetObjManager& t); static void register_class(NetworkingObjects::NetObjManager& t);
static void delay_post_assignment_update(DrawingProgram& drawP, CanvasComponent& comp); static void delay_post_assignment_update(DrawingProgram& drawP, CanvasComponent& comp);
void save_file(cereal::PortableBinaryOutputArchive& a) const; void save_file(cereal::PortableBinaryOutputArchive& a) const;
@ -61,7 +61,7 @@ class CanvasComponentContainer {
}; };
unsigned get_mipmap_level(const DrawData& drawData) const; unsigned get_mipmap_level(const DrawData& drawData) const;
CanvasComponent* allocate_comp(CanvasComponent::CompType type); CanvasComponent* allocate_comp(CanvasComponentType type);
void canvas_do_transform(SkCanvas* canvas, const TransformDrawData& transformData) const; void canvas_do_transform(SkCanvas* canvas, const TransformDrawData& transformData) const;
TransformDrawData calculate_draw_transform(const DrawData& drawData) const; TransformDrawData calculate_draw_transform(const DrawData& drawData) const;
void calculate_world_bounds(); void calculate_world_bounds();

View file

@ -0,0 +1,10 @@
#pragma once
#include <cstdint>
enum class CanvasComponentType : uint8_t {
BRUSHSTROKE = 0,
RECTANGLE,
ELLIPSE,
TEXTBOX,
IMAGE
};

View file

@ -1,11 +1,12 @@
#include "EllipseCanvasComponent.hpp" #include "EllipseCanvasComponent.hpp"
#include "CanvasComponent.hpp"
#include "Helpers/ConvertVec.hpp" #include "Helpers/ConvertVec.hpp"
#include "Helpers/SCollision.hpp" #include "Helpers/SCollision.hpp"
#include <include/core/SkPathBuilder.h> #include <include/core/SkPathBuilder.h>
#include "../DrawCollision.hpp" #include "../DrawCollision.hpp"
CanvasComponent::CompType EllipseCanvasComponent::get_type() const { CanvasComponentType EllipseCanvasComponent::get_type() const {
return CompType::ELLIPSE; return CanvasComponentType::ELLIPSE;
} }
void EllipseCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const { void EllipseCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@ -51,6 +52,11 @@ void EllipseCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
create_collider(); create_collider();
} }
void EllipseCanvasComponent::set_data_from(const CanvasComponent& other) {
auto& otherEllipse = static_cast<const EllipseCanvasComponent&>(other);
d = otherEllipse.d;
}
bool EllipseCanvasComponent::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const { bool EllipseCanvasComponent::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const {
return collisionTree.is_collide(checkAgainst); return collisionTree.is_collide(checkAgainst);
} }

View file

@ -5,11 +5,12 @@
class EllipseCanvasComponent : public CanvasComponent { class EllipseCanvasComponent : public CanvasComponent {
public: public:
virtual CompType get_type() const override; virtual CanvasComponentType get_type() const override;
virtual void save(cereal::PortableBinaryOutputArchive& a) const override; virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load(cereal::PortableBinaryInputArchive& a) override; virtual void load(cereal::PortableBinaryInputArchive& a) override;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override; virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
virtual void set_data_from(const CanvasComponent& other) override;
// User input data // User input data
struct Data { struct Data {

View file

@ -9,8 +9,8 @@
#include "../DrawCollision.hpp" #include "../DrawCollision.hpp"
#include "CanvasComponentContainer.hpp" #include "CanvasComponentContainer.hpp"
CanvasComponent::CompType ImageCanvasComponent::get_type() const { CanvasComponentType ImageCanvasComponent::get_type() const {
return CompType::IMAGE; return CanvasComponentType::IMAGE;
} }
void ImageCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const { void ImageCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@ -48,6 +48,11 @@ void ImageCanvasComponent::draw_download_progress_bar(SkCanvas* canvas, const Dr
} }
} }
void ImageCanvasComponent::set_data_from(const CanvasComponent& other) {
auto& otherImage = static_cast<const ImageCanvasComponent&>(other);
d = otherImage.d;
}
void ImageCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const { void ImageCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const {
ResourceDisplay* display = drawData.rMan->get_display_data(d.imageID); ResourceDisplay* display = drawData.rMan->get_display_data(d.imageID);
if(display) if(display)

View file

@ -10,7 +10,8 @@ class ImageCanvasComponent : public CanvasComponent {
virtual void load(cereal::PortableBinaryInputArchive& a) override; virtual void load(cereal::PortableBinaryInputArchive& a) override;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override; virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
virtual CompType get_type() const override; virtual CanvasComponentType get_type() const override;
virtual void set_data_from(const CanvasComponent& other) override;
void draw_download_progress_bar(SkCanvas* canvas, const DrawData& drawData, float progress) const; void draw_download_progress_bar(SkCanvas* canvas, const DrawData& drawData, float progress) const;

View file

@ -7,8 +7,8 @@
#include "../SharedTypes.hpp" #include "../SharedTypes.hpp"
#include "../DrawCollision.hpp" #include "../DrawCollision.hpp"
CanvasComponent::CompType RectangleCanvasComponent::get_type() const { CanvasComponentType RectangleCanvasComponent::get_type() const {
return CompType::RECTANGLE; return CanvasComponentType::RECTANGLE;
} }
void RectangleCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const { void RectangleCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@ -45,6 +45,11 @@ void RectangleCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData)
} }
} }
void RectangleCanvasComponent::set_data_from(const CanvasComponent& other) {
auto& otherRect = static_cast<const RectangleCanvasComponent&>(other);
d = otherRect.d;
}
void RectangleCanvasComponent::initialize_draw_data(DrawingProgram& drawP) { void RectangleCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data(); create_draw_data();
create_collider(); create_collider();

View file

@ -10,7 +10,8 @@ class RectangleCanvasComponent : public CanvasComponent {
virtual void load(cereal::PortableBinaryInputArchive& a) override; virtual void load(cereal::PortableBinaryInputArchive& a) override;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override; virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
virtual CompType get_type() const override; virtual CanvasComponentType get_type() const override;
virtual void set_data_from(const CanvasComponent& other) override;
// User input data // User input data
struct Data { struct Data {

View file

@ -21,8 +21,8 @@ TextBoxCanvasComponent::TextBoxCanvasComponent():
textBox->set_initial_text_style_modifier(std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{"Roboto"}})); textBox->set_initial_text_style_modifier(std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{"Roboto"}}));
} }
CanvasComponent::CompType TextBoxCanvasComponent::get_type() const { CanvasComponentType TextBoxCanvasComponent::get_type() const {
return CompType::TEXTBOX; return CanvasComponentType::TEXTBOX;
} }
void TextBoxCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const { void TextBoxCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@ -58,6 +58,13 @@ void TextBoxCanvasComponent::load_file(cereal::PortableBinaryInputArchive& a, Ve
} }
} }
void TextBoxCanvasComponent::set_data_from(const CanvasComponent& other) {
auto& otherTextBox = static_cast<const TextBoxCanvasComponent&>(other);
d = otherTextBox.d;
*cursor = *otherTextBox.cursor;
textBox->set_rich_text_data(otherTextBox.textBox->get_rich_text_data());
}
void TextBoxCanvasComponent::init_text_box(DrawingProgram& drawP) { void TextBoxCanvasComponent::init_text_box(DrawingProgram& drawP) {
textBox->set_font_data(drawP.world.main.fonts); // Getting a segfault relating to the paragraph cache means that the font collection hasn't been set yet textBox->set_font_data(drawP.world.main.fonts); // Getting a segfault relating to the paragraph cache means that the font collection hasn't been set yet
textBox->set_width(d.p2.x() - d.p1.x() - TEXTBOX_PADDING * 2.0f); textBox->set_width(d.p2.x() - d.p1.x() - TEXTBOX_PADDING * 2.0f);

View file

@ -10,11 +10,12 @@ class TextBoxCanvasComponent : public CanvasComponent {
constexpr static float TEXTBOX_PADDING = 5.0f; constexpr static float TEXTBOX_PADDING = 5.0f;
TextBoxCanvasComponent(); TextBoxCanvasComponent();
virtual CompType get_type() const override; virtual CanvasComponentType get_type() const override;
virtual void save(cereal::PortableBinaryOutputArchive& a) const override; virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load(cereal::PortableBinaryInputArchive& a) override; virtual void load(cereal::PortableBinaryInputArchive& a) override;
virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override; virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override; virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
virtual void set_data_from(const CanvasComponent& other) override;
// User input data // User input data
struct Data { struct Data {
@ -26,6 +27,8 @@ class TextBoxCanvasComponent : public CanvasComponent {
} d; } d;
private: private:
friend class TextBoxEditTool;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override;
virtual void initialize_draw_data(DrawingProgram& drawP) override; virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const override; virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const override;

View file

@ -1,9 +1,9 @@
#include "DrawData.hpp" #include "DrawData.hpp"
#include "DrawComponents/DrawComponent.hpp" #include "CanvasComponents/CanvasComponentContainer.hpp"
void DrawData::refresh_draw_optimizing_values() { void DrawData::refresh_draw_optimizing_values() {
clampDrawBetween = true; clampDrawBetween = true;
clampDrawMinimum = cam.c.inverseScale >> DRAWCOMP_MIN_SHIFT_BEFORE_DISAPPEAR; clampDrawMinimum = cam.c.inverseScale >> CanvasComponentContainer::COMP_MIN_SHIFT_BEFORE_DISAPPEAR;
mipMapLevelOne = cam.c.inverseScale >> DRAWCOMP_MIPMAP_LEVEL_ONE; mipMapLevelOne = cam.c.inverseScale >> CanvasComponentContainer::COMP_MIPMAP_LEVEL_ONE;
mipMapLevelTwo = cam.c.inverseScale >> DRAWCOMP_MIPMAP_LEVEL_TWO; mipMapLevelTwo = cam.c.inverseScale >> CanvasComponentContainer::COMP_MIPMAP_LEVEL_TWO;
} }

View file

@ -7,6 +7,7 @@
#include "../CanvasComponents/BrushStrokeCanvasComponent.hpp" #include "../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp" #include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp"
#include "Helpers/NetworkingObjects/NetObjWeakPtr.hpp" #include "Helpers/NetworkingObjects/NetObjWeakPtr.hpp"
#include "../CanvasComponents/CanvasComponentContainer.hpp"
#include <chrono> #include <chrono>
#define VEL_SMOOTH_MIN 0.6 #define VEL_SMOOTH_MIN 0.6
@ -25,6 +26,13 @@ void BrushTool::switch_tool(DrawingProgramToolType newTool) {
commit_stroke(); commit_stroke();
} }
void BrushTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
isDrawing = false;
objInfoBeingEdited = nullptr;
}
}
bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) { bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) {
auto& points = brushStroke.d->points; auto& points = brushStroke.d->points;
if(points.size() >= 1 && (newPoint - points[points.size() - 1].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT) if(points.size() >= 1 && (newPoint - points[points.size() - 1].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT)
@ -83,7 +91,7 @@ void BrushTool::tool_update() {
if(isPenDown) { if(isPenDown) {
if(!isDrawing) { if(!isDrawing) {
isDrawing = true; isDrawing = true;
CanvasComponentContainer* newBrushStrokeContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponent::CompType::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());
BrushStrokeCanvasComponentPoint p; BrushStrokeCanvasComponentPoint p;
@ -94,16 +102,11 @@ void BrushTool::tool_update() {
newBrushStroke.d->color = drawP.controls.foregroundColor; newBrushStroke.d->color = drawP.controls.foregroundColor;
newBrushStroke.d->hasRoundCaps = hasRoundCaps; newBrushStroke.d->hasRoundCaps = hasRoundCaps;
newBrushStrokeContainer->coords = drawP.world.drawData.cam.c; newBrushStrokeContainer->coords = drawP.world.drawData.cam.c;
intermediateContainer = drawP.components->push_back_and_send_create(drawP.components, newBrushStrokeContainer)->obj; objInfoBeingEdited = drawP.components->push_back_and_send_create(drawP.components, newBrushStrokeContainer);
addedTemporaryPoint = false; addedTemporaryPoint = false;
} }
else { else {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> containerPtr = intermediateContainer.lock(); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(!containerPtr) {
isDrawing = false;
intermediateContainer.reset();
return;
}
BrushStrokeCanvasComponent& brushStroke = static_cast<BrushStrokeCanvasComponent&>(containerPtr->get_comp()); BrushStrokeCanvasComponent& brushStroke = static_cast<BrushStrokeCanvasComponent&>(containerPtr->get_comp());
BrushStrokeCanvasComponentPoint p; BrushStrokeCanvasComponentPoint p;
@ -130,7 +133,6 @@ void BrushTool::tool_update() {
if((!drawingMinimumRelativeToSize && distToPrev >= 10.0) || (drawingMinimumRelativeToSize && distToPrev >= drawP.controls.relativeWidth * BrushStrokeCanvasComponent::DRAW_MINIMUM_LIMIT)) { if((!drawingMinimumRelativeToSize && distToPrev >= 10.0) || (drawingMinimumRelativeToSize && distToPrev >= drawP.controls.relativeWidth * BrushStrokeCanvasComponent::DRAW_MINIMUM_LIMIT)) {
brushStroke.d->points.back() = p; brushStroke.d->points.back() = p;
addedTemporaryPoint = false; addedTemporaryPoint = false;
containerPtr->send_comp_update(drawP, true);
if(midwayInterpolation) { if(midwayInterpolation) {
if(brushStroke.d->points.size() != 2) // Don't interpolate the first point if(brushStroke.d->points.size() != 2) // Don't interpolate the first point
@ -138,8 +140,10 @@ void BrushTool::tool_update() {
prevPointUnaltered = p.pos; prevPointUnaltered = p.pos;
} }
} }
containerPtr->commit_update(drawP);
} }
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
} }
} }
else if(isDrawing) { else if(isDrawing) {
@ -149,12 +153,10 @@ void BrushTool::tool_update() {
} }
void BrushTool::commit_stroke() { void BrushTool::commit_stroke() {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> lockedPtr = intermediateContainer.lock(); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(lockedPtr) { containerPtr->commit_update(drawP);
lockedPtr->commit_update(drawP); containerPtr->send_comp_update(drawP, true);
lockedPtr->send_comp_update(drawP, true); objInfoBeingEdited = nullptr;
}
intermediateContainer.reset();
} }
void BrushTool::gui_toolbox() { void BrushTool::gui_toolbox() {

View file

@ -20,6 +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 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;
@ -36,7 +37,7 @@ class BrushTool : public DrawingProgramToolBase {
}; };
std::deque<SmoothingPoint> penSmoothingData; std::deque<SmoothingPoint> penSmoothingData;
NetworkingObjects::NetObjWeakPtr<CanvasComponentContainer> intermediateContainer; CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
bool isDrawing = false; bool isDrawing = false;
bool hasRoundCaps = true; bool hasRoundCaps = true;
bool drawingMinimumRelativeToSize = true; bool drawingMinimumRelativeToSize = true;

View file

@ -50,14 +50,11 @@ void DrawingProgram::set_component_list_callbacks() {
c->obj->set_owner_obj_info(c); c->obj->set_owner_obj_info(c);
c->obj->commit_update(*this); // Run commit update on insert so that world bounds are calculated c->obj->commit_update(*this); // Run commit update on insert so that world bounds are calculated
compCache.add_component(c); compCache.add_component(c);
if(drawTool->get_type() == DrawingProgramToolType::ERASER) {
EraserTool* eraserTool = static_cast<EraserTool*>(drawTool.get());
eraserTool->erasedComponents.erase(c);
}
}); });
components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) { components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) {
compCache.erase_component(c); compCache.erase_component(c);
selection.erase_component(c); selection.erase_component(c);
drawTool->erase_component(c);
}); });
components->set_post_sync_callback([&]() { components->set_post_sync_callback([&]() {
clear_draw_cache(); clear_draw_cache();
@ -303,6 +300,7 @@ void DrawingProgram::update() {
selection.update(); selection.update();
drawTool->tool_update(); drawTool->tool_update();
// Switch tools after the tool update, not before, so that we dont have to call erase_component on the toolToSwitchToAfterUpdate as well (components will not be erased in this time period)
if(toolToSwitchToAfterUpdate) { if(toolToSwitchToAfterUpdate) {
switch_to_tool_ptr(std::move(toolToSwitchToAfterUpdate)); switch_to_tool_ptr(std::move(toolToSwitchToAfterUpdate));
toolToSwitchToAfterUpdate = nullptr; toolToSwitchToAfterUpdate = nullptr;

View file

@ -5,7 +5,7 @@ DrawingProgramEditToolBase::DrawingProgramEditToolBase(DrawingProgram& initDrawP
drawP(initDrawP) drawP(initDrawP)
{} {}
bool DrawingProgramEditToolBase::right_click_popup_gui(const std::shared_ptr<DrawComponent>& comp, Vector2f popupPos) { bool DrawingProgramEditToolBase::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& 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;

View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <include/core/SkCanvas.h> #include <include/core/SkCanvas.h>
#include "../DrawData.hpp" #include "../DrawData.hpp"
#include "../DrawComponents/DrawComponent.hpp" #include "../CanvasComponents/CanvasComponentContainer.hpp"
class DrawingProgram; class DrawingProgram;
class EditTool; class EditTool;
@ -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 std::shared_ptr<DrawComponent>& a, std::any& prevData) = 0; virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& a, std::any& prevData) = 0; virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& a) = 0; virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& a) = 0; virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0;
virtual bool right_click_popup_gui(const std::shared_ptr<DrawComponent>& comp, Vector2f popupPos); virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos);
virtual ~DrawingProgramEditToolBase(); virtual ~DrawingProgramEditToolBase();
protected: protected:
DrawingProgram& drawP; DrawingProgram& drawP;

View file

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <include/core/SkCanvas.h> #include <include/core/SkCanvas.h>
#include "../DrawData.hpp" #include "../DrawData.hpp"
#include "../CanvasComponents/CanvasComponentContainer.hpp"
class DrawingProgram; class DrawingProgram;
@ -27,6 +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 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;

View file

@ -24,15 +24,10 @@ 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(controls.isEditing) { if(isEditing) {
std::shared_ptr<DrawComponent> a = controls.compToEdit.lock(); bool editHappened = compEditTool->edit_gui(objInfoBeingEdited);
if(a) { if(editHappened)
bool editHappened = controls.compEditTool->edit_gui(a); objInfoBeingEdited->obj->commit_update(drawP);
if(editHappened) {
a->commit_update(drawP);
a->client_send_update(drawP, true);
}
}
} }
else { else {
t.gui.push_id("edit tool"); t.gui.push_id("edit tool");
@ -41,70 +36,73 @@ void EditTool::gui_toolbox() {
} }
} }
void EditTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(erasedComp == objInfoBeingEdited)
switch_tool(get_type());
}
bool EditTool::right_click_popup_gui(Vector2f popupPos) { bool EditTool::right_click_popup_gui(Vector2f popupPos) {
if(controls.isEditing) if(isEditing)
return controls.compEditTool->right_click_popup_gui(controls.compToEdit.lock(), popupPos); return compEditTool->right_click_popup_gui(objInfoBeingEdited, popupPos);
else else
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
} }
void EditTool::add_point_handle(const HandleData& handle) { void EditTool::add_point_handle(const HandleData& handle) {
controls.pointHandles.emplace_back(handle); pointHandles.emplace_back(handle);
} }
void EditTool::switch_tool(DrawingProgramToolType newTool) { void EditTool::switch_tool(DrawingProgramToolType newTool) {
auto a = controls.compToEdit.lock(); if(objInfoBeingEdited) {
if(a && a->collabListInfo.lock()) { compEditTool->commit_edit_updates(objInfoBeingEdited, prevData);
controls.compEditTool->commit_edit_updates(a, controls.prevData); objInfoBeingEdited->obj->commit_update(drawP);
a->commit_update(drawP); objInfoBeingEdited->obj->send_comp_update(drawP, true);
a->client_send_update(drawP, true);
} }
controls.compToEdit.reset(); objInfoBeingEdited = nullptr;
controls.pointHandles.clear(); pointHandles.clear();
controls.pointDragging = nullptr; pointDragging = nullptr;
controls.isEditing = false; 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 std::shared_ptr<DrawComponent>& comp) { void EditTool::edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
controls.isEditing = true; isEditing = true;
switch(comp->get_type()) { switch(comp->obj->get_comp().get_type()) {
case DRAWCOMPONENT_TEXTBOX: { case CanvasComponentType::TEXTBOX: {
controls.compEditTool = std::make_unique<TextBoxEditTool>(drawP); compEditTool = std::make_unique<TextBoxEditTool>(drawP);
break; break;
} }
case DRAWCOMPONENT_ELLIPSE: { case CanvasComponentType::ELLIPSE: {
controls.compEditTool = std::make_unique<EllipseDrawEditTool>(drawP); compEditTool = std::make_unique<EllipseDrawEditTool>(drawP);
break; break;
} }
case DRAWCOMPONENT_RECTANGLE: { case CanvasComponentType::RECTANGLE: {
controls.compEditTool = std::make_unique<RectDrawEditTool>(drawP); compEditTool = std::make_unique<RectDrawEditTool>(drawP);
break; break;
} }
case DRAWCOMPONENT_IMAGE: { case CanvasComponentType::IMAGE: {
controls.compEditTool = std::make_unique<ImageEditTool>(drawP); compEditTool = std::make_unique<ImageEditTool>(drawP);
break; break;
} }
default: { default: {
controls.isEditing = false; isEditing = false;
break; break;
} }
} }
if(controls.isEditing) { if(isEditing) {
controls.compToEdit = comp; objInfoBeingEdited = comp;
controls.compEditTool->edit_start(*this, comp, controls.prevData); compEditTool->edit_start(*this, objInfoBeingEdited, prevData);
comp->lastUpdateTime = std::chrono::steady_clock::now();
} }
} }
bool EditTool::is_editable(const std::shared_ptr<DrawComponent>& comp) { bool EditTool::is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
return comp->get_type() != DRAWCOMPONENT_BRUSHSTROKE; return comp->obj->get_comp().get_type() != CanvasComponentType::BRUSHSTROKE;
} }
void EditTool::tool_update() { void EditTool::tool_update() {
if(!controls.isEditing) { if(!isEditing) {
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);
@ -118,11 +116,11 @@ 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) {
CollabListType::ObjectInfoPtr selectedObjectToEdit = drawP.selection.get_front_object_colliding_with(camCMouseAABB); CanvasComponentContainer::ObjInfoSharedPtr selectedObjectToEdit = drawP.selection.get_front_object_colliding_with(camCMouseAABB);
if(selectedObjectToEdit && is_editable(selectedObjectToEdit->obj)) { if(selectedObjectToEdit && is_editable(selectedObjectToEdit)) {
drawP.selection.deselect_all(); drawP.selection.deselect_all();
edit_start(selectedObjectToEdit->obj); edit_start(selectedObjectToEdit);
modifySelection = false; modifySelection = false;
} }
} }
@ -144,60 +142,53 @@ void EditTool::tool_update() {
cMouseCircle.circle.emplace_back(mouseCircle); cMouseCircle.circle.emplace_back(mouseCircle);
cMouseCircle.recalculate_bounds(); cMouseCircle.recalculate_bounds();
std::shared_ptr<DrawComponent> a = controls.compToEdit.lock(); bool isMovingPoint = false;
if(a) { bool clickedAway = false;
bool isMovingPoint = false; if(!pointDragging && drawP.controls.leftClick) {
bool clickedAway = false; for(HandleData& h : pointHandles) {
if(!controls.pointDragging && drawP.controls.leftClick) { if(SCollision::collide(mouseCircle, SCollision::Circle<float>(drawP.world.drawData.cam.c.to_space(objInfoBeingEdited->obj->coords.from_space(*h.p)), drawP.drag_point_radius()))) {
for(HandleData& h : controls.pointHandles) { pointDragging = &h;
if(SCollision::collide(mouseCircle, SCollision::Circle<float>(drawP.world.drawData.cam.c.to_space(a->coords.from_space(*h.p)), drawP.drag_point_radius()))) {
controls.pointDragging = &h;
isMovingPoint = true;
break;
}
}
if(!isMovingPoint && !a->collides_with_cam_coords(drawP.world.drawData.cam.c, cMouseCircle))
clickedAway = true;
}
else if(controls.pointDragging) {
if(drawP.controls.leftClickHeld) {
Vector2f newPos = a->coords.get_mouse_pos(drawP.world);
if(newPos != *controls.pointDragging->p) {
if(controls.pointDragging->min)
newPos = cwise_vec_max((*controls.pointDragging->min + Vector2f{controls.pointDragging->minimumDistanceBetweenBoundsAndPoint, controls.pointDragging->minimumDistanceBetweenBoundsAndPoint}).eval(), newPos);
if(controls.pointDragging->max)
newPos = cwise_vec_min((*controls.pointDragging->max - Vector2f{controls.pointDragging->minimumDistanceBetweenBoundsAndPoint, controls.pointDragging->minimumDistanceBetweenBoundsAndPoint}).eval(), newPos);
*controls.pointDragging->p = newPos;
a->commit_update(drawP);
a->client_send_update(drawP, false);
}
isMovingPoint = true; isMovingPoint = true;
break;
} }
else
controls.pointDragging = nullptr;
} }
if(!isMovingPoint && !objInfoBeingEdited->obj->collides_with_cam_coords(drawP.world.drawData.cam.c, cMouseCircle))
a->lastUpdateTime = std::chrono::steady_clock::now(); clickedAway = true;
bool shouldNotReset = controls.compEditTool->edit_update(a);
if(!shouldNotReset || clickedAway)
switch_tool(get_type());
} }
else else if(pointDragging) {
if(drawP.controls.leftClickHeld) {
Vector2f newPos = objInfoBeingEdited->obj->coords.get_mouse_pos(drawP.world);
if(newPos != *pointDragging->p) {
if(pointDragging->min)
newPos = cwise_vec_max((*pointDragging->min + Vector2f{pointDragging->minimumDistanceBetweenBoundsAndPoint, pointDragging->minimumDistanceBetweenBoundsAndPoint}).eval(), newPos);
if(pointDragging->max)
newPos = cwise_vec_min((*pointDragging->max - Vector2f{pointDragging->minimumDistanceBetweenBoundsAndPoint, pointDragging->minimumDistanceBetweenBoundsAndPoint}).eval(), newPos);
*pointDragging->p = newPos;
objInfoBeingEdited->obj->commit_update(drawP);
}
isMovingPoint = true;
}
else
pointDragging = nullptr;
}
objInfoBeingEdited->obj->send_comp_update(drawP, false);
bool shouldNotReset = compEditTool->edit_update(objInfoBeingEdited);
if(!shouldNotReset || clickedAway)
switch_tool(get_type()); switch_tool(get_type());
} }
} }
bool EditTool::prevent_undo_or_redo() { bool EditTool::prevent_undo_or_redo() {
return controls.isEditing; return isEditing;
} }
void EditTool::draw(SkCanvas* canvas, const DrawData& drawData) { void EditTool::draw(SkCanvas* canvas, const DrawData& drawData) {
if(controls.isEditing) { if(isEditing) {
std::shared_ptr<DrawComponent> a = controls.compToEdit.lock(); if(objInfoBeingEdited) {
if(a) { for(HandleData& h : pointHandles)
for(HandleData& h : controls.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((a->coords.from_space(*h.p))), {0.1f, 0.9f, 0.9f, 1.0f}, drawData);
} }
} }
} }

View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include "../DrawComponents/DrawEllipse.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <any> #include <any>
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
@ -22,20 +21,19 @@ 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 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 std::shared_ptr<DrawComponent>& comp); void edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp);
bool is_editable(const std::shared_ptr<DrawComponent>& comp); bool is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp);
struct EditControls { std::unique_ptr<DrawingProgramEditToolBase> compEditTool;
std::unique_ptr<DrawingProgramEditToolBase> compEditTool; std::vector<HandleData> pointHandles;
std::vector<HandleData> pointHandles; CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
std::weak_ptr<DrawComponent> compToEdit; bool isEditing = false;
bool isEditing = false; HandleData* pointDragging = nullptr;
HandleData* pointDragging = nullptr; std::any prevData;
std::any prevData;
} controls;
}; };

View file

@ -11,66 +11,48 @@ EllipseDrawEditTool::EllipseDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool EllipseDrawEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) { bool EllipseDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
auto a = std::static_pointer_cast<DrawEllipse>(comp); auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool ellipse"); t.gui.push_id("edit tool ellipse");
t.gui.text_label_centered("Edit Ellipse"); t.gui.text_label_centered("Edit Ellipse");
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0; if(t.gui.radio_button_field("fillonly", "Fill only", a.d.fillStrokeMode == 0)) a.d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1; if(t.gui.radio_button_field("outlineonly", "Outline only", a.d.fillStrokeMode == 1)) a.d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2; if(t.gui.radio_button_field("filloutline", "Fill and Outline", a.d.fillStrokeMode == 2)) a.d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) { if(a.d.fillStrokeMode == 0 || a.d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() { t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight)) if(t.gui.color_button_big("Fill Color", &a.d.fillColor, &a.d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor); t.color_selector_right(&a.d.fillColor == t.colorRight ? nullptr : &a.d.fillColor);
t.gui.text_label("Fill Color"); t.gui.text_label("Fill Color");
}); });
} }
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) { if(a.d.fillStrokeMode == 1 || a.d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f); t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a.d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() { t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight)) if(t.gui.color_button_big("Outline Color", &a.d.strokeColor, &a.d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor); t.color_selector_right(&a.d.strokeColor == t.colorRight ? nullptr : &a.d.strokeColor);
t.gui.text_label("Outline Color"); t.gui.text_label("Outline Color");
}); });
} }
t.gui.pop_id(); t.gui.pop_id();
bool editHappened = (!oldData.has_value()) || (a->d != oldData); bool editHappened = (!oldData.has_value()) || (a.d != oldData);
oldData = a->d; oldData = a.d;
return editHappened; return editHappened;
} }
void EllipseDrawEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void EllipseDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
auto a = std::static_pointer_cast<DrawEllipse>(comp); auto& a = static_cast<EllipseCanvasComponent&>(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 EllipseDrawEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void EllipseDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
auto a = std::static_pointer_cast<DrawEllipse>(comp);
DrawEllipse::Data pData = std::any_cast<DrawEllipse::Data>(prevData);
DrawEllipse::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&drawP = drawP, a, pData]() {
a->d = pData;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
},
[&drawP = drawP, a, cData]() {
a->d = cData;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
}
});
} }
bool EllipseDrawEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) { bool EllipseDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
return true; return true;
} }

View file

@ -1,6 +1,7 @@
#pragma once #pragma once
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
#include "../DrawComponents/DrawEllipse.hpp" #include "../CanvasComponents/CanvasComponentContainer.hpp"
#include "../CanvasComponents//EllipseCanvasComponent.hpp"
#include <any> #include <any>
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
@ -9,12 +10,12 @@ 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 std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
private: private:
void commit(); void commit();
std::optional<DrawEllipse::Data> oldData; std::optional<EllipseCanvasComponent::Data> oldData;
}; };

View file

@ -7,6 +7,7 @@
#include "../InputManager.hpp" #include "../InputManager.hpp"
#include <cereal/types/vector.hpp> #include <cereal/types/vector.hpp>
#include "../CanvasComponents/EllipseCanvasComponent.hpp" #include "../CanvasComponents/EllipseCanvasComponent.hpp"
#include "../CanvasComponents/CanvasComponentContainer.hpp"
EllipseDrawTool::EllipseDrawTool(DrawingProgram& initDrawP): EllipseDrawTool::EllipseDrawTool(DrawingProgram& initDrawP):
DrawingProgramToolBase(initDrawP) DrawingProgramToolBase(initDrawP)
@ -28,6 +29,13 @@ void EllipseDrawTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void EllipseDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool EllipseDrawTool::right_click_popup_gui(Vector2f popupPos) { bool EllipseDrawTool::right_click_popup_gui(Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.paint_popup(popupPos); t.paint_popup(popupPos);
@ -42,7 +50,7 @@ void EllipseDrawTool::tool_update() {
switch(drawStage) { switch(drawStage) {
case 0: { case 0: {
if(drawP.controls.leftClick) { if(drawP.controls.leftClick) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponent::CompType::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;
@ -55,14 +63,14 @@ void EllipseDrawTool::tool_update() {
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;
intermediateContainer = drawP.components->push_back_and_send_create(drawP.components, newContainer)->obj; objInfoBeingEdited = drawP.components->push_back_and_send_create(drawP.components, newContainer);
drawStage = 1; drawStage = 1;
} }
break; break;
} }
case 1: { case 1: {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> containerPtr = intermediateContainer.lock(); if(drawP.controls.leftClickHeld) {
if(drawP.controls.leftClickHeld && containerPtr) { NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
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());
@ -72,7 +80,7 @@ void EllipseDrawTool::tool_update() {
ellipse.d.p1 = cwise_vec_min(startAt, newPos); ellipse.d.p1 = cwise_vec_min(startAt, newPos);
ellipse.d.p2 = cwise_vec_max(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); ellipse.d.p2 = ensure_points_have_distance(ellipse.d.p1, ellipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, true); containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP); containerPtr->commit_update(drawP);
} }
else { else {
@ -89,12 +97,10 @@ bool EllipseDrawTool::prevent_undo_or_redo() {
} }
void EllipseDrawTool::commit() { void EllipseDrawTool::commit() {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> lockedPtr = intermediateContainer.lock(); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(lockedPtr) { containerPtr->commit_update(drawP);
lockedPtr->commit_update(drawP); containerPtr->send_comp_update(drawP, true);
drawP.world.delayedUpdateObjectManager.send_update_to_all<CanvasComponentContainer>(lockedPtr, true); objInfoBeingEdited = nullptr;
}
intermediateContainer.reset();
} }
void EllipseDrawTool::draw(SkCanvas* canvas, const DrawData& drawData) { void EllipseDrawTool::draw(SkCanvas* canvas, const DrawData& drawData) {

View file

@ -12,6 +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 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,5 +23,5 @@ class EllipseDrawTool : public DrawingProgramToolBase {
Vector2f startAt; Vector2f startAt;
int fillStrokeMode = 1; int fillStrokeMode = 1;
int drawStage = 0; int drawStage = 0;
NetworkingObjects::NetObjWeakPtr<CanvasComponentContainer> intermediateContainer; CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
}; };

View file

@ -26,6 +26,10 @@ bool EraserTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void EraserTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
erasedComponents.erase(erasedComp);
}
void EraserTool::switch_tool(DrawingProgramToolType newTool) { void EraserTool::switch_tool(DrawingProgramToolType newTool) {
DrawingProgramCache::move_components_from_bvh_nodes_to_set(erasedComponents, erasedBVHNodes); DrawingProgramCache::move_components_from_bvh_nodes_to_set(erasedComponents, erasedBVHNodes);
if(!erasedComponents.empty()) { if(!erasedComponents.empty()) {

View file

@ -12,6 +12,7 @@ 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 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;

View file

@ -45,6 +45,9 @@ bool EyeDropperTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void EyeDropperTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
}
void EyeDropperTool::tool_update() { void EyeDropperTool::tool_update() {
if(drawP.controls.leftClick) { if(drawP.controls.leftClick) {
SkSurfaceProps props; SkSurfaceProps props;

View file

@ -10,6 +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 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;

View file

@ -33,6 +33,9 @@ DrawingProgramToolType GridModifyTool::get_type() {
return DrawingProgramToolType::GRIDMODIFY; return DrawingProgramToolType::GRIDMODIFY;
} }
void GridModifyTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
}
void GridModifyTool::gui_toolbox() { void GridModifyTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("Grid modify tool"); t.gui.push_id("Grid modify tool");

View file

@ -13,6 +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 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;

View file

@ -1,6 +1,6 @@
#include "ImageEditTool.hpp" #include "ImageEditTool.hpp"
#include "DrawingProgram.hpp" #include "DrawingProgram.hpp"
#include "../DrawComponents/DrawImage.hpp" #include "../CanvasComponents/ImageCanvasComponent.hpp"
#include "../World.hpp" #include "../World.hpp"
#include "../Toolbar.hpp" #include "../Toolbar.hpp"
#include "../MainProgram.hpp" #include "../MainProgram.hpp"
@ -16,23 +16,22 @@ ImageEditTool::ImageEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
void ImageEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void ImageEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
} }
void ImageEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void ImageEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
} }
bool ImageEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) { bool ImageEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
return true; return true;
} }
bool ImageEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) { bool ImageEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
std::shared_ptr<DrawImage> a = std::static_pointer_cast<DrawImage>(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");
t.gui.text_label_centered("File Properties"); t.gui.text_label_centered("File Properties");
std::optional<ResourceData> resourceData = drawP.world.rMan.get_resource(a->d.imageID); std::optional<ResourceData> resourceData = drawP.world.rMan.get_resource(a.d.imageID);
if(resourceData) { if(resourceData) {
t.gui.text_label("Name: " + resourceData->name); t.gui.text_label("Name: " + resourceData->name);

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 std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
}; };

View file

@ -46,6 +46,9 @@ 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::switch_tool(DrawingProgramToolType newTool) { void LassoSelectTool::switch_tool(DrawingProgramToolType newTool) {
if(!drawP.is_selection_allowing_tool(newTool)) if(!drawP.is_selection_allowing_tool(newTool))
drawP.selection.deselect_all(); drawP.selection.deselect_all();

View file

@ -3,7 +3,6 @@
#include "../DrawData.hpp" #include "../DrawData.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include "../CoordSpaceHelper.hpp" #include "../CoordSpaceHelper.hpp"
#include "../DrawComponents/DrawComponent.hpp"
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
class DrawingProgram; class DrawingProgram;
@ -14,6 +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 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;

View file

@ -25,6 +25,9 @@ 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::tool_update() { void PanCanvasTool::tool_update() {
} }

View file

@ -9,6 +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 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;

View file

@ -9,65 +9,47 @@ RectDrawEditTool::RectDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool RectDrawEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) { bool RectDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(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");
t.gui.text_label_centered("Edit Rectangle"); t.gui.text_label_centered("Edit Rectangle");
t.gui.slider_scalar_field("relradiuswidth", "Corner Radius", &a->d.cornerRadius, 0.0f, 40.0f); t.gui.slider_scalar_field("relradiuswidth", "Corner Radius", &a.d.cornerRadius, 0.0f, 40.0f);
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0; if(t.gui.radio_button_field("fillonly", "Fill only", a.d.fillStrokeMode == 0)) a.d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1; if(t.gui.radio_button_field("outlineonly", "Outline only", a.d.fillStrokeMode == 1)) a.d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2; if(t.gui.radio_button_field("filloutline", "Fill and Outline", a.d.fillStrokeMode == 2)) a.d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) { if(a.d.fillStrokeMode == 0 || a.d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() { t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight)) if(t.gui.color_button_big("Fill Color", &a.d.fillColor, &a.d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor); t.color_selector_right(&a.d.fillColor == t.colorRight ? nullptr : &a.d.fillColor);
t.gui.text_label("Fill Color"); t.gui.text_label("Fill Color");
}); });
} }
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) { if(a.d.fillStrokeMode == 1 || a.d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f); t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a.d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() { t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight)) if(t.gui.color_button_big("Outline Color", &a.d.strokeColor, &a.d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor); t.color_selector_right(&a.d.strokeColor == t.colorRight ? nullptr : &a.d.strokeColor);
t.gui.text_label("Outline Color"); t.gui.text_label("Outline Color");
}); });
} }
t.gui.pop_id(); t.gui.pop_id();
bool editHappened = (!oldData.has_value()) || (a->d != oldData); bool editHappened = (!oldData.has_value()) || (a.d != oldData);
oldData = a->d; oldData = a.d;
return editHappened; return editHappened;
} }
void RectDrawEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void RectDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(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 std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void RectDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(comp);
DrawRectangle::Data pData = std::any_cast<DrawRectangle::Data>(prevData);
DrawRectangle::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&drawP = drawP, a, pData]() {
a->d = pData;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
},
[&drawP = drawP, a, cData]() {
a->d = cData;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
}
});
} }
bool RectDrawEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) { bool RectDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
return true; return true;
} }

View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
#include "../DrawComponents/DrawRectangle.hpp" #include "../CanvasComponents/RectangleCanvasComponent.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <any> #include <any>
@ -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 std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override; virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override; virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
private: private:
std::optional<DrawRectangle::Data> oldData; std::optional<RectangleCanvasComponent::Data> oldData;
}; };

View file

@ -4,6 +4,7 @@
#include "../DrawData.hpp" #include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include "../CanvasComponents/RectangleCanvasComponent.hpp" #include "../CanvasComponents/RectangleCanvasComponent.hpp"
#include "../CanvasComponents/CanvasComponentContainer.hpp"
RectDrawTool::RectDrawTool(DrawingProgram& initDrawP): RectDrawTool::RectDrawTool(DrawingProgram& initDrawP):
DrawingProgramToolBase(initDrawP) DrawingProgramToolBase(initDrawP)
@ -26,6 +27,13 @@ void RectDrawTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void RectDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) { bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.paint_popup(popupPos); t.paint_popup(popupPos);
@ -33,7 +41,7 @@ bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
} }
void RectDrawTool::switch_tool(DrawingProgramToolType newTool) { void RectDrawTool::switch_tool(DrawingProgramToolType newTool) {
commit_rectangle(); commit();
drawStage = 0; drawStage = 0;
} }
@ -41,7 +49,7 @@ void RectDrawTool::tool_update() {
switch(drawStage) { switch(drawStage) {
case 0: { case 0: {
if(drawP.controls.leftClick) { if(drawP.controls.leftClick) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponent::CompType::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;
@ -54,14 +62,14 @@ void RectDrawTool::tool_update() {
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;
intermediateContainer = drawP.components->push_back_and_send_create(drawP.components, newContainer)->obj; objInfoBeingEdited = drawP.components->push_back_and_send_create(drawP.components, newContainer);
drawStage = 1; drawStage = 1;
} }
break; break;
} }
case 1: { case 1: {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> containerPtr = intermediateContainer.lock(); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(drawP.controls.leftClickHeld && containerPtr) { if(drawP.controls.leftClickHeld) {
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());
@ -71,11 +79,11 @@ void RectDrawTool::tool_update() {
rectangle.d.p1 = cwise_vec_min(startAt, newPos); rectangle.d.p1 = cwise_vec_min(startAt, newPos);
rectangle.d.p2 = cwise_vec_max(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); rectangle.d.p2 = ensure_points_have_distance(rectangle.d.p1, rectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, true); containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP); containerPtr->commit_update(drawP);
} }
else { else {
commit_rectangle(); commit();
drawStage = 0; drawStage = 0;
} }
break; break;
@ -87,13 +95,11 @@ bool RectDrawTool::prevent_undo_or_redo() {
return (drawStage == 1); return (drawStage == 1);
} }
void RectDrawTool::commit_rectangle() { void RectDrawTool::commit() {
NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer> lockedPtr = intermediateContainer.lock(); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(lockedPtr) { containerPtr->commit_update(drawP);
lockedPtr->commit_update(drawP); containerPtr->send_comp_update(drawP, true);
drawP.world.delayedUpdateObjectManager.send_update_to_all<CanvasComponentContainer>(lockedPtr, true); objInfoBeingEdited = nullptr;
}
intermediateContainer.reset();
} }
void RectDrawTool::draw(SkCanvas* canvas, const DrawData& drawData) { void RectDrawTool::draw(SkCanvas* canvas, const DrawData& drawData) {

View file

@ -11,16 +11,17 @@ 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 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;
private: private:
void commit_rectangle(); void commit();
Vector2f startAt; Vector2f startAt;
float relativeRadiusWidth = 10.0f; float relativeRadiusWidth = 10.0f;
int fillStrokeMode = 1; int fillStrokeMode = 1;
int drawStage = 0; int drawStage = 0;
NetworkingObjects::NetObjWeakPtr<CanvasComponentContainer> intermediateContainer; CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
}; };

View file

@ -20,6 +20,9 @@ void RectSelectTool::gui_toolbox() {
drawP.world.main.toolbar.gui.text_label_centered("Rectangle Select"); drawP.world.main.toolbar.gui.text_label_centered("Rectangle Select");
} }
void RectSelectTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
}
bool RectSelectTool::right_click_popup_gui(Vector2f popupPos) { bool RectSelectTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos); return drawP.selection_action_menu(popupPos);
} }

View file

@ -2,7 +2,6 @@
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include "../CoordSpaceHelper.hpp" #include "../CoordSpaceHelper.hpp"
#include "../DrawComponents/DrawComponent.hpp"
class DrawingProgram; class DrawingProgram;
@ -11,6 +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 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;

View file

@ -117,6 +117,9 @@ bool ScreenshotTool::right_click_popup_gui(Vector2f popupPos) {
return true; return true;
} }
void ScreenshotTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
}
void ScreenshotTool::take_screenshot(const std::filesystem::path& filePath) { void ScreenshotTool::take_screenshot(const std::filesystem::path& filePath) {
if(controls.imageSize.x() <= 0 || controls.imageSize.y() <= 0) { if(controls.imageSize.x() <= 0 || controls.imageSize.y() <= 0) {
std::cout << "[ScreenshotTool::take_screenshot] Image size is 0 or negative" << std::endl; std::cout << "[ScreenshotTool::take_screenshot] Image size is 0 or negative" << std::endl;

View file

@ -13,6 +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 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;

View file

@ -20,8 +20,8 @@ TextBoxEditTool::TextBoxEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP) DrawingProgramEditToolBase(initDrawP)
{} {}
bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) { bool TextBoxEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool text"); t.gui.push_id("edit tool text");
@ -31,7 +31,7 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
t.gui.text_label("Font"); t.gui.text_label("Font");
if(t.gui.font_picker("font picker", &newFontName)) { if(t.gui.font_picker("font picker", &newFontName)) {
currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES] = std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{newFontName.c_str(), newFontName.size()}}); currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES] = std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{newFontName.c_str(), newFontName.size()}});
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES]);});
} }
}); });
@ -39,13 +39,13 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
if(t.gui.svg_icon_button("Bold button", "data/icons/RemixIcon/bold.svg", newIsBold)) { if(t.gui.svg_icon_button("Bold button", "data/icons/RemixIcon/bold.svg", newIsBold)) {
newIsBold = !newIsBold; newIsBold = !newIsBold;
currentMods[TextStyleModifier::ModifierType::WEIGHT] = std::make_shared<WeightTextStyleModifier>(newIsBold ? SkFontStyle::Weight::kBold_Weight : SkFontStyle::Weight::kNormal_Weight); currentMods[TextStyleModifier::ModifierType::WEIGHT] = std::make_shared<WeightTextStyleModifier>(newIsBold ? SkFontStyle::Weight::kBold_Weight : SkFontStyle::Weight::kNormal_Weight);
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::WEIGHT]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::WEIGHT]);});
} }
if(t.gui.svg_icon_button("Italic button", "data/icons/RemixIcon/italic.svg", newIsItalic)) { if(t.gui.svg_icon_button("Italic button", "data/icons/RemixIcon/italic.svg", newIsItalic)) {
newIsItalic = !newIsItalic; newIsItalic = !newIsItalic;
currentMods[TextStyleModifier::ModifierType::SLANT] = std::make_shared<SlantTextStyleModifier>(newIsItalic ? SkFontStyle::Slant::kItalic_Slant : SkFontStyle::Slant::kUpright_Slant); currentMods[TextStyleModifier::ModifierType::SLANT] = std::make_shared<SlantTextStyleModifier>(newIsItalic ? SkFontStyle::Slant::kItalic_Slant : SkFontStyle::Slant::kUpright_Slant);
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SLANT]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SLANT]);});
} }
bool decorationEdited = false; bool decorationEdited = false;
@ -63,29 +63,29 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
} }
if(decorationEdited) { if(decorationEdited) {
currentMods[TextStyleModifier::ModifierType::DECORATION] = std::make_shared<DecorationTextStyleModifier>(get_new_decoration_value()); currentMods[TextStyleModifier::ModifierType::DECORATION] = std::make_shared<DecorationTextStyleModifier>(get_new_decoration_value());
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::DECORATION]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::DECORATION]);});
} }
}); });
t.gui.left_to_right_line_centered_layout([&]() { t.gui.left_to_right_line_centered_layout([&]() {
if(t.gui.svg_icon_button("Align left button", "data/icons/RemixIcon/align-left.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kLeft)) if(t.gui.svg_icon_button("Align left button", "data/icons/RemixIcon/align-left.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kLeft))
add_undo([&](){a->textBox->set_text_alignment_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kLeft);}); add_undo([&](){a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kLeft);});
if(t.gui.svg_icon_button("Align center button", "data/icons/RemixIcon/align-center.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kCenter)) if(t.gui.svg_icon_button("Align center button", "data/icons/RemixIcon/align-center.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kCenter))
add_undo([&](){a->textBox->set_text_alignment_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kCenter);}); add_undo([&](){a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kCenter);});
if(t.gui.svg_icon_button("Align right button", "data/icons/RemixIcon/align-right.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kRight)) if(t.gui.svg_icon_button("Align right button", "data/icons/RemixIcon/align-right.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kRight))
add_undo([&](){a->textBox->set_text_alignment_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kRight);}); add_undo([&](){a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kRight);});
if(t.gui.svg_icon_button("Align justify button", "data/icons/RemixIcon/align-justify.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kJustify)) if(t.gui.svg_icon_button("Align justify button", "data/icons/RemixIcon/align-justify.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kJustify))
add_undo([&](){a->textBox->set_text_alignment_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kJustify);}); add_undo([&](){a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kJustify);});
if(t.gui.svg_icon_button("Text direction left", "data/icons/RemixIcon/text-direction-l.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kLtr)) if(t.gui.svg_icon_button("Text direction left", "data/icons/RemixIcon/text-direction-l.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kLtr))
add_undo([&](){a->textBox->set_text_direction_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kLtr);}); add_undo([&](){a.textBox->set_text_direction_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kLtr);});
if(t.gui.svg_icon_button("Text direction right", "data/icons/RemixIcon/text-direction-r.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kRtl)) if(t.gui.svg_icon_button("Text direction right", "data/icons/RemixIcon/text-direction-r.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kRtl))
add_undo([&](){a->textBox->set_text_direction_between(a->cursor->selectionBeginPos.fParagraphIndex, a->cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kRtl);}); add_undo([&](){a.textBox->set_text_direction_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kRtl);});
}); });
if(t.gui.slider_scalar_field<uint32_t>("Font Size Slider", "Font Size", &newFontSize, 3, 100)) { if(t.gui.slider_scalar_field<uint32_t>("Font Size Slider", "Font Size", &newFontSize, 3, 100)) {
hold_undo_data("Font Size", a); hold_undo_data("Font Size", a);
currentMods[TextStyleModifier::ModifierType::SIZE] = std::make_shared<SizeTextStyleModifier>(newFontSize); currentMods[TextStyleModifier::ModifierType::SIZE] = std::make_shared<SizeTextStyleModifier>(newFontSize);
a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SIZE]); a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SIZE]);
} }
else else
release_undo_data("Font Size"); release_undo_data("Font Size");
@ -104,7 +104,7 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
if((&newTextColor == t.colorRight) && t.isUpdatingColorRight) { if((&newTextColor == t.colorRight) && t.isUpdatingColorRight) {
currentMods[TextStyleModifier::ModifierType::COLOR] = std::make_shared<ColorTextStyleModifier>(newTextColor); currentMods[TextStyleModifier::ModifierType::COLOR] = std::make_shared<ColorTextStyleModifier>(newTextColor);
a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::COLOR]); a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::COLOR]);
} }
@ -115,7 +115,7 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
if(newHighlightColor.w() == 0.0f) { // Make highlight appear when the button is pressed if(newHighlightColor.w() == 0.0f) { // Make highlight appear when the button is pressed
newHighlightColor.w() = 1.0f; newHighlightColor.w() = 1.0f;
currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor); currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);});
} }
t.color_selector_right(&newHighlightColor == t.colorRight ? nullptr : &newHighlightColor); t.color_selector_right(&newHighlightColor == t.colorRight ? nullptr : &newHighlightColor);
} }
@ -123,7 +123,7 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
if(t.gui.svg_icon_button("Remove Highlight Color", "data/icons/close.svg")) { if(t.gui.svg_icon_button("Remove Highlight Color", "data/icons/close.svg")) {
newHighlightColor = {0.0f, 0.0f, 0.0f, 0.0f}; newHighlightColor = {0.0f, 0.0f, 0.0f, 0.0f};
currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor); currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
add_undo_if_selecting_area(a, [&]() {a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);}); add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);});
} }
} }
t.gui.text_label("Highlight Color"); t.gui.text_label("Highlight Color");
@ -136,26 +136,26 @@ bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
if((&newHighlightColor == t.colorRight) && t.isUpdatingColorRight) { if((&newHighlightColor == t.colorRight) && t.isUpdatingColorRight) {
currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor); currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
a->textBox->set_text_style_modifier_between(a->cursor->selectionBeginPos, a->cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]); a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);
} }
t.gui.pop_id(); t.gui.pop_id();
if(a->textBox->inputChangedTextBox) if(a.textBox->inputChangedTextBox)
set_styles_at_selection(a); set_styles_at_selection(a);
// NOTE: There should be a system that periodically sends updates even if no changes are made, since unreliable channels can drop update data // NOTE: There should be a system that periodically sends updates even if no changes are made, since unreliable channels can drop update data
bool oldInputChangedTextBox = a->textBox->inputChangedTextBox; bool oldInputChangedTextBox = a.textBox->inputChangedTextBox;
a->textBox->inputChangedTextBox = false; a.textBox->inputChangedTextBox = false;
return oldInputChangedTextBox; return oldInputChangedTextBox;
} }
bool TextBoxEditTool::right_click_popup_gui(const std::shared_ptr<DrawComponent>& comp, Vector2f popupPos) { bool TextBoxEditTool::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
bool shouldClose = false; bool shouldClose = false;
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
t.gui.list_popup_menu("Text popup menu", popupPos, [&]() { t.gui.list_popup_menu("Text popup menu", popupPos, [&]() {
t.gui.text_label_light("Text menu"); t.gui.text_label_light("Text menu");
InputManager& input = drawP.world.main.input; InputManager& input = drawP.world.main.input;
@ -167,14 +167,14 @@ bool TextBoxEditTool::right_click_popup_gui(const std::shared_ptr<DrawComponent>
input.call_text_paste(false); input.call_text_paste(false);
shouldClose = true; shouldClose = true;
} }
if(a->cursor->selectionBeginPos != a->cursor->selectionEndPos) { if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos) {
if(t.gui.text_button_left_transparent("Copy", "Copy")) { if(t.gui.text_button_left_transparent("Copy", "Copy")) {
input.set_clipboard_plain_and_richtext_pair(a->textBox->process_copy(*a->cursor)); input.set_clipboard_plain_and_richtext_pair(a.textBox->process_copy(*a.cursor));
shouldClose = true; shouldClose = true;
} }
if(t.gui.text_button_left_transparent("Cut", "Cut")) { if(t.gui.text_button_left_transparent("Cut", "Cut")) {
input.text.do_textbox_operation_with_undo([&]() { input.text.do_textbox_operation_with_undo([&]() {
input.set_clipboard_plain_and_richtext_pair(a->textBox->process_cut(*a->cursor)); input.set_clipboard_plain_and_richtext_pair(a.textBox->process_cut(*a.cursor));
}); });
shouldClose = true; shouldClose = true;
} }
@ -183,15 +183,15 @@ bool TextBoxEditTool::right_click_popup_gui(const std::shared_ptr<DrawComponent>
return !shouldClose; return !shouldClose;
} }
void TextBoxEditTool::hold_undo_data(const std::string& undoName, const std::shared_ptr<DrawTextBox>& a) { void TextBoxEditTool::hold_undo_data(const std::string& undoName, TextBoxCanvasComponent& a) {
auto it = undoHeldData.find(undoName); auto it = undoHeldData.find(undoName);
if(it != undoHeldData.end()) { if(it != undoHeldData.end()) {
std::pair<RichText::TextBox::Cursor, RichText::TextData>& undoData = it->second; std::pair<RichText::TextBox::Cursor, RichText::TextData>& undoData = it->second;
if(undoData.first != *a->cursor) if(undoData.first != *a.cursor)
undoHeldData.erase(it); undoHeldData.erase(it);
} }
else if(a->cursor->selectionBeginPos != a->cursor->selectionEndPos) else if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos)
undoHeldData.emplace(undoName, std::pair<RichText::TextBox::Cursor, RichText::TextData>{*a->cursor, a->textBox->get_rich_text_data()}); undoHeldData.emplace(undoName, std::pair<RichText::TextBox::Cursor, RichText::TextData>{*a.cursor, a.textBox->get_rich_text_data()});
} }
void TextBoxEditTool::release_undo_data(const std::string& undoName) { void TextBoxEditTool::release_undo_data(const std::string& undoName) {
@ -204,8 +204,8 @@ void TextBoxEditTool::release_undo_data(const std::string& undoName) {
} }
} }
void TextBoxEditTool::add_undo_if_selecting_area(const std::shared_ptr<DrawTextBox>& a, const std::function<void()>& func) { void TextBoxEditTool::add_undo_if_selecting_area(TextBoxCanvasComponent& a, const std::function<void()>& func) {
if(a->cursor->selectionBeginPos == a->cursor->selectionEndPos) if(a.cursor->selectionBeginPos == a.cursor->selectionEndPos)
func(); func();
else { else {
InputManager& input = drawP.world.main.input; InputManager& input = drawP.world.main.input;
@ -229,13 +229,13 @@ uint8_t TextBoxEditTool::get_new_decoration_value() {
return toRet; return toRet;
} }
void TextBoxEditTool::set_styles_at_selection(const std::shared_ptr<DrawTextBox>& a) { void TextBoxEditTool::set_styles_at_selection(TextBoxCanvasComponent& a) {
TextPosition start = std::min(a->cursor->selectionBeginPos, a->cursor->selectionEndPos); TextPosition start = std::min(a.cursor->selectionBeginPos, a.cursor->selectionEndPos);
TextPosition end = std::max(a->cursor->selectionBeginPos, a->cursor->selectionEndPos); TextPosition end = std::max(a.cursor->selectionBeginPos, a.cursor->selectionEndPos);
if(start == end) if(start == end)
currentMods = a->textBox->get_mods_used_at_pos(a->textBox->move(TextBox::Movement::LEFT, start)); currentMods = a.textBox->get_mods_used_at_pos(a.textBox->move(TextBox::Movement::LEFT, start));
else else
currentMods = a->textBox->get_mods_used_at_pos(start); currentMods = a.textBox->get_mods_used_at_pos(start);
newFontName = std::static_pointer_cast<FontFamiliesTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES])->get_families().back().c_str(); newFontName = std::static_pointer_cast<FontFamiliesTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES])->get_families().back().c_str();
newFontSize = std::static_pointer_cast<SizeTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::SIZE])->get_size(); newFontSize = std::static_pointer_cast<SizeTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::SIZE])->get_size();
@ -247,78 +247,54 @@ void TextBoxEditTool::set_styles_at_selection(const std::shared_ptr<DrawTextBox>
newIsLinethrough = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kLineThrough; newIsLinethrough = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kLineThrough;
newIsOverline = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kOverline; newIsOverline = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kOverline;
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 std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void TextBoxEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
a.d.editing = false;
a->d.editing = false; comp->obj->commit_update(drawP);
auto pData = std::any_cast<TextBoxEditToolAllData>(prevData);
TextBoxEditToolAllData cData = get_all_data(a);
TextData richText = a->textBox->get_rich_text_data();
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&drawP = drawP, a, pData]() {
a->d = pData.textboxData;
a->textBox->set_rich_text_data(pData.richText);
a->d.editing = false;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
},
[&drawP = drawP, a, cData]() {
a->d = cData.textboxData;
a->textBox->set_rich_text_data(cData.richText);
a->d.editing = false;
a->client_send_update(drawP, true);
a->commit_update(drawP);
return true;
}
});
} }
TextBoxEditTool::TextBoxEditToolAllData TextBoxEditTool::get_all_data(const std::shared_ptr<DrawTextBox>& a) { TextBoxEditTool::TextBoxEditToolAllData TextBoxEditTool::get_all_data(const TextBoxCanvasComponent& a) {
return { return {
.textboxData = a->d, .textboxData = a.d,
.richText = a->textBox->get_rich_text_data() .richText = a.textBox->get_rich_text_data()
}; };
} }
void TextBoxEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) { void TextBoxEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(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;
cur = std::make_shared<TextBox::Cursor>(); cur = std::make_shared<TextBox::Cursor>();
Vector2f textSelectPos = a->get_mouse_pos(drawP); Vector2f textSelectPos = a.get_mouse_pos(drawP);
textbox->process_mouse_left_button(*cur, textSelectPos, 1, false, false); textbox->process_mouse_left_button(*cur, textSelectPos, 1, false, false);
prevData = get_all_data(a); prevData = get_all_data(a);
a->d.editing = true; a.d.editing = true;
a->textBox->inputChangedTextBox = true; a.textBox->inputChangedTextBox = true;
a->commit_update(drawP);
a->client_send_update(drawP, false);
set_styles_at_selection(a); set_styles_at_selection(a);
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});
} }
bool TextBoxEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) { bool TextBoxEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
SCollision::ColliderCollection<float> mousePointCollection; SCollision::ColliderCollection<float> mousePointCollection;
mousePointCollection.circle.emplace_back(drawP.world.main.input.mouse.pos, 1.0f); mousePointCollection.circle.emplace_back(drawP.world.main.input.mouse.pos, 1.0f);
mousePointCollection.recalculate_bounds(); mousePointCollection.recalculate_bounds();
a->init_text_box(drawP); a.init_text_box(drawP);
InputManager& input = drawP.world.main.input; InputManager& input = drawP.world.main.input;
bool collidesWithBox = a->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection); bool collidesWithBox = comp->obj->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection);
input.text.set_rich_text_box_input(a->textBox, a->cursor, true, currentMods); input.text.set_rich_text_box_input(a.textBox, a.cursor, true, currentMods);
a->textBox->process_mouse_left_button(*a->cursor, a->get_mouse_pos(drawP), (drawP.controls.leftClick && collidesWithBox) ? drawP.world.main.input.mouse.leftClicks : 0, drawP.controls.leftClickHeld, input.key(InputManager::KEY_GENERIC_LSHIFT).held); a.textBox->process_mouse_left_button(*a.cursor, a.get_mouse_pos(drawP), (drawP.controls.leftClick && collidesWithBox) ? drawP.world.main.input.mouse.leftClicks : 0, drawP.controls.leftClickHeld, input.key(InputManager::KEY_GENERIC_LSHIFT).held);
return true; return true;
} }

View file

@ -1,5 +1,5 @@
#pragma once #pragma once
#include "../DrawComponents/DrawTextBox.hpp" #include "../CanvasComponents/TextBoxCanvasComponent.hpp"
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <any> #include <any>
@ -10,14 +10,14 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
public: public:
TextBoxEditTool(DrawingProgram& initDrawP); TextBoxEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& a, std::any& prevData) override; virtual void edit_start(EditTool& editTool,const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& a, std::any& prevData) override; virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& a) override; virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& a) override; virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool right_click_popup_gui(const std::shared_ptr<DrawComponent>& comp, Vector2f popupPos) override; virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) override;
private: private:
struct TextBoxEditToolAllData { struct TextBoxEditToolAllData {
DrawTextBox::Data textboxData; TextBoxCanvasComponent::Data textboxData;
RichText::TextData richText; RichText::TextData richText;
}; };
@ -33,11 +33,11 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
RichText::ParagraphStyleData currentPStyle; RichText::ParagraphStyleData currentPStyle;
uint8_t get_new_decoration_value(); uint8_t get_new_decoration_value();
void set_styles_at_selection(const std::shared_ptr<DrawTextBox>& a); void set_styles_at_selection(TextBoxCanvasComponent& a);
void add_undo_if_selecting_area(const std::shared_ptr<DrawTextBox>& a, const std::function<void()>& func); void add_undo_if_selecting_area(TextBoxCanvasComponent& a, const std::function<void()>& func);
void add_undo(const std::function<void()>& func); void add_undo(const std::function<void()>& func);
void hold_undo_data(const std::string& undoName, const std::shared_ptr<DrawTextBox>& a); void hold_undo_data(const std::string& undoName, TextBoxCanvasComponent& a);
void release_undo_data(const std::string& undoName); void release_undo_data(const std::string& undoName);
std::unordered_map<std::string, std::pair<RichText::TextBox::Cursor, RichText::TextData>> undoHeldData; std::unordered_map<std::string, std::pair<RichText::TextBox::Cursor, RichText::TextData>> undoHeldData;
@ -46,5 +46,5 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
std::vector<std::string> sortedFontList; std::vector<std::string> sortedFontList;
TextBoxEditToolAllData get_all_data(const std::shared_ptr<DrawTextBox>& a); TextBoxEditToolAllData get_all_data(const TextBoxCanvasComponent& a);
}; };

View file

@ -7,6 +7,8 @@
#include "Helpers/SCollision.hpp" #include "Helpers/SCollision.hpp"
#include <cereal/types/vector.hpp> #include <cereal/types/vector.hpp>
#include <memory> #include <memory>
#include "../CanvasComponents/TextBoxCanvasComponent.hpp"
#include "../CanvasComponents/CanvasComponentContainer.hpp"
#include "EditTool.hpp" #include "EditTool.hpp"
TextBoxTool::TextBoxTool(DrawingProgram& initDrawP): TextBoxTool::TextBoxTool(DrawingProgram& initDrawP):
@ -24,6 +26,13 @@ void TextBoxTool::gui_toolbox() {
t.gui.pop_id(); t.gui.pop_id();
} }
void TextBoxTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) { bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar; Toolbar& t = drawP.world.main.toolbar;
t.paint_popup(popupPos); t.paint_popup(popupPos);
@ -32,50 +41,50 @@ bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
void TextBoxTool::switch_tool(DrawingProgramToolType newTool) { void TextBoxTool::switch_tool(DrawingProgramToolType newTool) {
commit(); commit();
controls.drawStage = 0; drawStage = 0;
} }
void TextBoxTool::tool_update() { void TextBoxTool::tool_update() {
switch(controls.drawStage) { switch(drawStage) {
case 0: { case 0: {
if(drawP.controls.leftClick) { if(drawP.controls.leftClick) {
controls.intermediateItem = std::make_shared<DrawTextBox>(); startAt = drawP.world.main.input.mouse.pos;
controls.startAt = drawP.world.main.input.mouse.pos; endAt = startAt;
controls.endAt = controls.startAt;
controls.intermediateItem->d.p1 = controls.intermediateItem->d.p2 = controls.startAt; CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::TEXTBOX);
controls.intermediateItem->d.p2 = ensure_points_have_distance(controls.intermediateItem->d.p1, controls.intermediateItem->d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); TextBoxCanvasComponent& newTextBox = static_cast<TextBoxCanvasComponent&>(newContainer->get_comp());
controls.intermediateItem->d.editing = true;
controls.intermediateItem->coords = drawP.world.drawData.cam.c; newTextBox.d.p1 = newTextBox.d.p2 = startAt;
controls.intermediateItem->lastUpdateTime = std::chrono::steady_clock::now(); newTextBox.d.p2 = ensure_points_have_distance(newTextBox.d.p1, newTextBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
uint64_t placement = drawP.components.client_list().size(); newTextBox.d.editing = true;
auto objAdd = drawP.components.client_insert(placement, controls.intermediateItem); newContainer->coords = drawP.world.drawData.cam.c;
controls.intermediateItem->client_send_place(drawP); objInfoBeingEdited = drawP.components->push_back_and_send_create(drawP.components, newContainer);
controls.intermediateItem->commit_update(drawP); drawStage = 1;
drawP.add_undo_place_component(objAdd);
controls.drawStage = 1;
} }
break; break;
} }
case 1: { case 1: {
Vector2f newPos = controls.intermediateItem->coords.get_mouse_pos(drawP.world); NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp());
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(controls.startAt.y() - newPos.y()); float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = controls.startAt.x() + (((newPos.x() - controls.startAt.x()) < 0.0f ? -1.0f : 1.0f) * height); newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
} }
controls.endAt = newPos; endAt = newPos;
controls.intermediateItem->d.p1 = cwise_vec_min(controls.endAt, controls.startAt); textBox.d.p1 = cwise_vec_min(endAt, startAt);
controls.intermediateItem->d.p2 = cwise_vec_max(controls.endAt, controls.startAt); textBox.d.p2 = cwise_vec_max(endAt, startAt);
controls.intermediateItem->d.p2 = ensure_points_have_distance(controls.intermediateItem->d.p1, controls.intermediateItem->d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS); textBox.d.p2 = ensure_points_have_distance(textBox.d.p1, textBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
controls.intermediateItem->lastUpdateTime = std::chrono::steady_clock::now();
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(controls.intermediateItem); editTool->edit_start(objInfoBeingEdited);
drawP.toolToSwitchToAfterUpdate = std::move(editTool); drawP.toolToSwitchToAfterUpdate = std::move(editTool);
return; return;
} }
else { else {
controls.intermediateItem->client_send_update(drawP, false); containerPtr->send_comp_update(drawP, false);
controls.intermediateItem->commit_update(drawP); containerPtr->commit_update(drawP);
} }
break; break;
} }
@ -83,15 +92,14 @@ void TextBoxTool::tool_update() {
} }
bool TextBoxTool::prevent_undo_or_redo() { bool TextBoxTool::prevent_undo_or_redo() {
return controls.intermediateItem != nullptr; return (drawStage == 1);
} }
void TextBoxTool::commit() { void TextBoxTool::commit() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) { NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
controls.intermediateItem->client_send_update(drawP, true); containerPtr->commit_update(drawP);
controls.intermediateItem->commit_update(drawP); containerPtr->send_comp_update(drawP, true);
} objInfoBeingEdited = nullptr;
controls.intermediateItem = nullptr;
} }
void TextBoxTool::draw(SkCanvas* canvas, const DrawData& drawData) { void TextBoxTool::draw(SkCanvas* canvas, const DrawData& drawData) {

View file

@ -1,8 +1,7 @@
#pragma once #pragma once
#include "../DrawComponents/DrawTextBox.hpp"
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <any> #include "../CanvasComponents/CanvasComponentContainer.hpp"
class DrawingProgram; class DrawingProgram;
@ -12,19 +11,16 @@ 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 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;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
private: private:
void edit_text(std::function<void()> toRun, const std::shared_ptr<DrawTextBox>& textBox);
void update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox);
void commit(); void commit();
struct TextBoxControls { Vector2f startAt;
Vector2f startAt; Vector2f endAt;
Vector2f endAt; int drawStage = 0;
int drawStage = 0; CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
std::shared_ptr<DrawTextBox> intermediateItem;
} controls;
}; };

View file

@ -25,6 +25,9 @@ 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::tool_update() { void ZoomCanvasTool::tool_update() {
} }

View file

@ -9,6 +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 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;

View file

@ -1,28 +1,12 @@
#include "ServerData.hpp" #include "ServerData.hpp"
#include "../DrawComponents/DrawComponent.hpp"
void ServerData::save(cereal::PortableBinaryOutputArchive& a) const { void ServerData::save(cereal::PortableBinaryOutputArchive& a) const {
a(canvasBackColor, canvasScale); a(canvasBackColor, canvasScale);
a((uint64_t)components.size());
for(uint64_t i = 0; i < components.size(); i++)
a(components[i]->get_type(), components[i]->id, components[i]->coords, *components[i]);
} }
void ServerData::load(cereal::PortableBinaryInputArchive& a) { void ServerData::load(cereal::PortableBinaryInputArchive& a) {
a(canvasBackColor, canvasScale); a(canvasBackColor, canvasScale);
uint64_t compCount;
a(compCount);
for(uint64_t i = 0; i < compCount; i++) {
DrawComponentType t;
a(t);
auto newComp = DrawComponent::allocate_comp_type(t);
a(newComp->id, newComp->coords, *newComp);
components.emplace_back(newComp);
idToComponentMap.emplace(newComp->id, newComp);
}
} }
void ServerData::scale_up(const WorldScalar& scaleUpAmount) { void ServerData::scale_up(const WorldScalar& scaleUpAmount) {
for(auto& c : components)
c->scale_up(scaleUpAmount);
} }

View file

@ -540,8 +540,9 @@ void Toolbar::top_toolbar() {
#else #else
open_file_selector("Open File", {{"Any File", "*"}}, [w = make_weak_ptr(main.world)](const std::filesystem::path& p, const auto& e) { open_file_selector("Open File", {{"Any File", "*"}}, [w = make_weak_ptr(main.world)](const std::filesystem::path& p, const auto& e) {
auto wLock = w.lock(); auto wLock = w.lock();
if(wLock) // NOTE: Implement again later
wLock->drawProg.add_file_to_canvas_by_path(p.string(), wLock->main.window.size.cast<float>() / 2.0f, false); //if(wLock)
// wLock->drawProg.add_file_to_canvas_by_path(p.string(), wLock->main.window.size.cast<float>() / 2.0f, false);
}); });
#endif #endif
} }
@ -1245,7 +1246,7 @@ void Toolbar::performance_metrics() {
std::stringstream a; std::stringstream a;
a << "FPS: " << std::fixed << std::setprecision(0) << (1.0 / main.deltaTime); a << "FPS: " << std::fixed << std::setprecision(0) << (1.0 / main.deltaTime);
gui.text_label(a.str()); gui.text_label(a.str());
gui.text_label("Item Count: " + std::to_string(main.world->drawProg.components.client_list().size())); gui.text_label("Item Count: " + std::to_string(main.world->drawProg.components->size()));
std::stringstream b; std::stringstream b;
b << "Coord: " << main.world->drawData.cam.c.pos.x().display_int_str(5) << ", " << main.world->drawData.cam.c.pos.y().display_int_str(5); b << "Coord: " << main.world->drawData.cam.c.pos.x().display_int_str(5) << ", " << main.world->drawData.cam.c.pos.y().display_int_str(5);
gui.text_label(b.str()); gui.text_label(b.str());

View file

@ -84,7 +84,7 @@ void World::init_net_obj_type_list() {
NetworkingObjects::register_ordered_list_class<Bookmark>(netObjMan); NetworkingObjects::register_ordered_list_class<Bookmark>(netObjMan);
delayedUpdateObjectManager.register_class<WorldGrid>(netObjMan); delayedUpdateObjectManager.register_class<WorldGrid>(netObjMan);
NetworkingObjects::register_ordered_list_class<WorldGrid>(netObjMan); NetworkingObjects::register_ordered_list_class<WorldGrid>(netObjMan);
CanvasComponentAllocator::register_class(delayedUpdateObjectManager, netObjMan); CanvasComponentAllocator::register_class(*this, netObjMan);
CanvasComponentContainer::register_class(netObjMan); CanvasComponentContainer::register_class(netObjMan);
} }