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

Working on moving canvas code to net objects (broken build)

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-14 18:57:40 +03:00
parent d2a0bfcda9
commit 45ba26446a
42 changed files with 605 additions and 3186 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/CanvasComponents/CanvasComponent.hpp
View file

@ -28,6 +28,7 @@ class CanvasComponent {
protected:
friend class CanvasComponentContainer;
friend class CanvasComponentAllocator;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) const = 0;
virtual void initialize_draw_data(DrawingProgram& drawP) = 0;

52
src/CanvasComponents/CanvasComponentAllocator.cpp
View file

@ -1,4 +1,6 @@
#include "CanvasComponentAllocator.hpp"
#include "CanvasComponentContainer.hpp"
#include "../DrawingProgram/DrawingProgram.hpp"
CanvasComponentAllocator::CanvasComponentAllocator() {}
@ -6,25 +8,35 @@ CanvasComponentAllocator::CanvasComponentAllocator(CanvasComponent::CompType typ
comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
}
void CanvasComponentAllocator::register_class(NetworkingObjects::NetObjManager& objMan) {
objMan.register_class<CanvasComponentAllocator, CanvasComponentAllocator, CanvasComponentAllocator, CanvasComponentAllocator>({
.writeConstructorFuncClient = write_constructor_func,
.readConstructorFuncClient = read_constructor_func,
.readUpdateFuncClient = nullptr,
.writeConstructorFuncServer = write_constructor_func,
.readConstructorFuncServer = read_constructor_func,
.readUpdateFuncServer = nullptr,
void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan) {
delayUpdateMan.register_class<CanvasComponentAllocator>(objMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<CanvasComponentAllocator>{
.writeConstructor = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
a(o.comp->get_type());
a(*o.comp);
},
.readConstructor = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
CanvasComponent::CompType typeToAllocate;
a(typeToAllocate);
o.comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
a(*o.comp);
},
.writeUpdate = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
a(*o.comp);
},
.readUpdate = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
a(*o.comp);
},
.allocateCopy = [](const CanvasComponentAllocator& o) {
auto theCopy = std::make_shared<CanvasComponentAllocator>();
theCopy->comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(o.comp->get_type()));
// Maybe do an assignment here
return theCopy;
},
.assignmentFunc = [](CanvasComponentAllocator& o, const CanvasComponentAllocator& o2) {
// Assignment still needs to be implemented
},
.postUpdateFunc = [&drawP](CanvasComponentAllocator& o) {
o.comp->compContainer->commit_update(drawP);
}
});
}
void CanvasComponentAllocator::write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<CanvasComponentAllocator>& o, cereal::PortableBinaryOutputArchive& a) {
a(o->comp->get_type());
a(*o->comp);
}
void CanvasComponentAllocator::read_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<CanvasComponentAllocator>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c) {
CanvasComponent::CompType typeToAllocate;
a(typeToAllocate);
o->comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
a(*o->comp);
}

8
src/CanvasComponents/CanvasComponentAllocator.hpp
View file

@ -2,14 +2,14 @@
#include <memory>
#include "CanvasComponent.hpp"
#include <Helpers/NetworkingObjects/NetObjTemporaryPtr.hpp>
#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
class DrawingProgram;
class CanvasComponentAllocator {
public:
CanvasComponentAllocator();
CanvasComponentAllocator(CanvasComponent::CompType typeToAllocate);
std::unique_ptr<CanvasComponent> comp;
static void register_class(NetworkingObjects::NetObjManager& objMan);
private:
static void write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<CanvasComponentAllocator>& o, cereal::PortableBinaryOutputArchive& a);
static void read_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<CanvasComponentAllocator>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c);
static void register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan);
};

36
src/CanvasComponents/CanvasComponentContainer.cpp
View file

@ -2,6 +2,8 @@
#include "CanvasComponentAllocator.hpp"
#include "../DrawData.hpp"
#include "../DrawingProgram/DrawingProgram.hpp"
#include "../World.hpp"
#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
using namespace NetworkingObjects;
@ -22,6 +24,10 @@ void CanvasComponentContainer::register_class(NetObjManager& objMan) {
});
}
void CanvasComponentContainer::send_comp_update(DrawingProgram& drawP, bool finalUpdate) {
drawP.world.delayedUpdateObjectManager.send_update_to_all<CanvasComponentAllocator>(compAllocator, finalUpdate);
}
void CanvasComponentContainer::write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<CanvasComponentContainer>& o, cereal::PortableBinaryOutputArchive& a) {
a(o->coords);
o->compAllocator.write_create_message(a);
@ -53,19 +59,25 @@ void CanvasComponentContainer::draw(SkCanvas* canvas, const DrawData& drawData)
canvas->restore();
}
void CanvasComponentContainer::set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo) {
objInfo = ownerObjInfo;
}
void CanvasComponentContainer::commit_update(DrawingProgram& drawP) {
//if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
// drawP.preupdate_component(objInfo);
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo);
get_comp().initialize_draw_data(drawP);
calculate_world_bounds();
//drawP.preupdate_component(objInfo);
drawP.preupdate_component(lockedObjInfo);
}
void CanvasComponentContainer::commit_transform(DrawingProgram& drawP) {
//if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
// drawP.preupdate_component(objInfo);
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo);
calculate_world_bounds();
//drawP.preupdate_component(objInfo);
drawP.preupdate_component(lockedObjInfo);
}
void CanvasComponentContainer::commit_update_dont_invalidate_cache(DrawingProgram& drawP) {
@ -73,6 +85,10 @@ void CanvasComponentContainer::commit_update_dont_invalidate_cache(DrawingProgra
calculate_world_bounds();
}
void CanvasComponentContainer::commit_transform_dont_invalidate_cache(DrawingProgram& drawP) {
calculate_world_bounds();
}
bool CanvasComponentContainer::collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) const {
return collides_with(camCoords, checkAgainstWorld, camCoords.world_collider_to_coords<SCollision::ColliderCollection<float>>(checkAgainstWorld));
}
@ -130,14 +146,10 @@ void CanvasComponentContainer::calculate_world_bounds() {
worldAABB = coords.collider_to_world<SCollision::AABB<WorldScalar>, SCollision::AABB<float>>(get_comp().get_obj_coord_bounds());
}
std::optional<SCollision::AABB<WorldScalar>> CanvasComponentContainer::get_world_bounds() const {
return worldAABB;
SCollision::AABB<WorldScalar> CanvasComponentContainer::get_world_bounds() const {
return worldAABB.value();
}
CanvasComponent& CanvasComponentContainer::get_comp() const {
return *compAllocator->comp;
}
const CoordSpaceHelper& CanvasComponentContainer::get_coords() const {
return coords;
}

18
src/CanvasComponents/CanvasComponentContainer.hpp
View file

@ -3,14 +3,17 @@
#include "CanvasComponent.hpp"
#include <Helpers/NetworkingObjects/NetObjManagerTypeList.hpp>
#include "../VersionConstants.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include <Helpers/NetworkingObjects/NetObjOwnerPtr.hpp>
class DrawingProgram;
class CanvasComponentAllocator;
class DrawingProgramCacheBVHNode;
class CanvasComponentContainer {
public:
typedef NetworkingObjects::NetObjOrderedList<CanvasComponentContainer> NetList;
typedef NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<CanvasComponentContainer>> NetListOwnerPtr;
typedef NetworkingObjects::NetObjOrderedListObjectInfo<CanvasComponentContainer> ObjInfo;
typedef std::shared_ptr<ObjInfo> ObjInfoSharedPtr;
typedef std::weak_ptr<ObjInfo> ObjInfoWeakPtr;
@ -29,16 +32,21 @@ class CanvasComponentContainer {
void save_file(cereal::PortableBinaryOutputArchive& a) const;
void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version);
CanvasComponent& get_comp() const;
const CoordSpaceHelper& get_coords() const;
std::optional<SCollision::AABB<WorldScalar>> get_world_bounds() const;
SCollision::AABB<WorldScalar> get_world_bounds() const;
void draw(SkCanvas* canvas, const DrawData& drawData) const;
void commit_update(DrawingProgram& drawP);
void commit_transform_dont_invalidate_cache(DrawingProgram& drawP); // Must be thread safe
void commit_transform(DrawingProgram& drawP);
void commit_update_dont_invalidate_cache(DrawingProgram& drawP); // Must be thread safe
bool should_draw(const DrawData& drawData) const;
bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) const;
bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
void set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo);
void send_comp_update(DrawingProgram& drawP, bool finalUpdate);
std::weak_ptr<DrawingProgramCacheBVHNode> parentBvhNode;
CoordSpaceHelper coords;
private:
friend class BrushStrokeCanvasComponent;
friend class ImageCanvasComponent;
@ -58,9 +66,7 @@ class CanvasComponentContainer {
TransformDrawData calculate_draw_transform(const DrawData& drawData) const;
void calculate_world_bounds();
ObjInfo* objInfo = nullptr;
ObjInfoWeakPtr objInfo;
std::optional<SCollision::AABB<WorldScalar>> worldAABB;
NetworkingObjects::NetObjOwnerPtr<CanvasComponentAllocator> compAllocator;
CoordSpaceHelper coords;
};

2
src/CanvasComponents/TextBoxCanvasComponent.cpp
View file

@ -84,7 +84,7 @@ void TextBoxCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) co
}
Vector2f TextBoxCanvasComponent::get_mouse_pos(DrawingProgram& drawP) const {
return compContainer->get_coords().get_mouse_pos(drawP.world) - d.p1 - Vector2f{TEXTBOX_PADDING, TEXTBOX_PADDING};
return compContainer->coords.get_mouse_pos(drawP.world) - d.p1 - Vector2f{TEXTBOX_PADDING, TEXTBOX_PADDING};
}
void TextBoxCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {