Started canvas component work, and moving to unique network pointers (build is broken)

src/BookmarkManager.cpp

@@ -23,32 +23,15 @@ void BookmarkManager::init() {
 }
 
 void BookmarkManager::add_bookmark(const std::string& name) {
-    NetworkingObjects::NetObjPtr<Bookmark> bookmarkPtr = bookmarks->emplace_back_direct(bookmarks, Bookmark{name, world.drawData.cam.c, world.main.window.size.cast<int32_t>()});
-    uint32_t pos = bookmarks->size() - 1;
-    world.undo.push({[&bookmarks = bookmarks, bookmarkPtr](){
-        bookmarks->erase(bookmarks, bookmarkPtr);
-        return true;
-    },
-    [&bookmarks = bookmarks, bookmarkPtr, pos]() {
-        bookmarks->insert_and_send_create(bookmarks, pos, bookmarkPtr);
-        return true;
-    }});
+    bookmarks->emplace_back_direct(bookmarks, Bookmark{name, world.drawData.cam.c, world.main.window.size.cast<int32_t>()});
 }
 
 void BookmarkManager::remove_bookmark(uint32_t bookmarkIndex) {
-    NetworkingObjects::NetObjPtr<Bookmark> bookmarkPtr = bookmarks->erase(bookmarks, bookmarkIndex);
-    world.undo.push({[&bookmarks = bookmarks, bookmarkPtr, bookmarkIndex]() {
-        bookmarks->insert_and_send_create(bookmarks, bookmarkIndex, bookmarkPtr);
-        return true;
-    },
-    [&bookmarks = bookmarks, bookmarkPtr](){
-        bookmarks->erase(bookmarks, bookmarkPtr);
-        return true;
-    }});
+    bookmarks->erase(bookmarks, bookmarkIndex);
 }
 
 void BookmarkManager::jump_to_bookmark(uint32_t bookmarkIndex) {
-    const NetworkingObjects::NetObjPtr<Bookmark>& b = bookmarks->at(bookmarkIndex);
+    auto& b = bookmarks->at(bookmarkIndex);
     world.drawData.cam.smooth_move_to(world, b->coords, b->windowSize.cast<float>());
 }
 

src/BookmarkManager.hpp

@@ -41,7 +41,7 @@ class BookmarkManager {
             }
         }
 
-        NetworkingObjects::NetObjPtr<NetworkingObjects::NetObjOrderedList<Bookmark>> bookmarks;
+        NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<Bookmark>> bookmarks;
     private:
         World& world;
 };

src/CanvasComponents/CanvasComponent.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdint>
+#include <cereal/archives/portable_binary.hpp>
+#include <Helpers/VersionNumber.hpp>
+
+class CanvasComponent {
+    public:
+        enum class CompType : uint8_t {
+            BRUSHSTROKE = 0,
+            RECTANGLE,
+            ELLIPSE,
+            TEXTBOX,
+            IMAGE
+        };
+    protected:
+        virtual void write_update() const;
+        virtual void read_update();
+        virtual void save_file(cereal::PortableBinaryOutputArchive& a) const;
+        virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version);
+};

src/CanvasComponents/CanvasComponentBrushStroke.hpp

@@ -0,0 +1,62 @@
+#pragma once
+#include "CanvasComponent.hpp"
+#include "Helpers/SCollision.hpp"
+#include <Helpers/Serializers.hpp>
+#include <include/core/SkPath.h>
+#include <include/core/SkPathBuilder.h>
+
+struct DrawBrushStrokePoint {
+    Vector2f pos;
+    float width;
+
+    template <typename Archive> void serialize(Archive& a) {
+        a(pos, width);
+    }
+};
+
+class CanvasComponentBrushStroke : public CanvasComponent {
+    public:
+        constexpr static float DRAW_MINIMUM_LIMIT = 0.3;
+
+        virtual DrawComponentType get_type() const override;
+        virtual void write_update(cereal::PortableBinaryOutputArchive& a) const override;
+        virtual void read_update(cereal::PortableBinaryInputArchive& a) override;
+        virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
+        virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
+
+        struct Data {
+            std::vector<DrawBrushStrokePoint> points;
+            Vector4f color;
+            bool hasRoundCaps;
+        };
+        std::shared_ptr<Data> d = std::make_shared<Data>(); // It's a pointer here since brush strokes cant be edited
+
+#ifndef IS_SERVER
+        virtual std::shared_ptr<DrawComponent> copy(DrawingProgram& drawP) const override;
+        virtual std::shared_ptr<DrawComponent> deep_copy(DrawingProgram& drawP) const override;
+
+        virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
+        virtual void initialize_draw_data(DrawingProgram& drawP) override;
+        virtual void update(DrawingProgram& drawP) override;
+        virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
+        void create_collider();
+        virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
+
+        virtual SCollision::AABB<float> get_obj_coord_bounds() const override;
+
+        std::shared_ptr<SkPath> brushPath;
+        SCollision::AABB<float> bounds;
+
+        std::array<std::shared_ptr<SkPath>, 2> brushPathLOD;
+    private:
+        std::vector<DrawBrushStrokePoint> every_nth_point_include_front_and_back(const std::vector<DrawBrushStrokePoint>& pts, size_t n);
+
+        void add_precheck_aabb_level(size_t level, const std::vector<SCollision::BVHContainer<float>>& levelArray);
+        std::vector<SCollision::AABB<float>> precheckAABBLevels;
+        void create_triangles(const std::function<bool(Vector2f, Vector2f, Vector2f)>& passTriangleFunc, const std::vector<DrawBrushStrokePoint>& smoothedPoints, size_t skipVertexCount, std::shared_ptr<SkPathBuilder> bPath);
+        std::vector<size_t> get_wedge_indices(const std::vector<DrawBrushStrokePoint>& points);
+        std::vector<DrawBrushStrokePoint> smooth_points(size_t beginIndex, size_t endIndex, unsigned numOfDivisions);
+        std::vector<DrawBrushStrokePoint> smooth_points_avg(size_t beginIndex, size_t endIndex, unsigned numOfDivisions);
+#endif
+};
+

src/CanvasComponents/CanvasComponentContainer.cpp

@@ -0,0 +1,41 @@
+#include "CanvasComponentContainer.hpp"
+
+CanvasComponentContainer::CanvasComponentContainer() { }
+
+CanvasComponentContainer::CanvasComponentContainer(CanvasComponent::CompType type) {
+    allocate_comp(type);
+}
+
+void CanvasComponentContainer::register_class(NetworkingObjects::NetObjManagerTypeList& t) {
+    t.register_class<CanvasComponentContainer, CanvasComponentContainer, CanvasComponentContainer, CanvasComponentContainer>({
+    });
+}
+
+std::unique_ptr<CanvasComponent> CanvasComponentContainer::allocate_comp(CanvasComponent::CompType type) {
+    switch(type) {
+        case CanvasComponent::CompType::BRUSHSTROKE:
+            return std::make_unique<CanvasComponentBrushStroke>();
+        case CanvasComponent::CompType::RECTANGLE:
+            return std::make_unique<CanvasComponentRectangle>();
+        case CanvasComponent::CompType::ELLIPSE:
+            return std::make_unique<CanvasComponentEllipse>();
+        case CanvasComponent::CompType::TEXTBOX:
+            return std::make_unique<CanvasComponentTextBox>();
+        case CanvasComponent::CompType::IMAGE:
+            return std::make_unique<CanvasComponentImage>();
+    }
+}
+
+void CanvasComponentContainer::save_file(cereal::PortableBinaryOutputArchive& a) const {
+}
+
+void CanvasComponentContainer::load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) {
+}
+
+const std::unique_ptr<CanvasComponent>& CanvasComponentContainer::get_comp() {
+    return comp;
+}
+
+const CoordSpaceHelper& CanvasComponentContainer::get_coords() {
+    return coords;
+}

src/CanvasComponents/CanvasComponentContainer.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include "../CoordSpaceHelper.hpp"
+#include "CanvasComponent.hpp"
+#include <Helpers/NetworkingObjects/NetObjManagerTypeList.hpp>
+#include "../VersionConstants.hpp"
+
+class CanvasComponentContainer {
+    public:
+        CanvasComponentContainer();
+        CanvasComponentContainer(CanvasComponent::CompType type);
+        static void register_class(NetworkingObjects::NetObjManagerTypeList& t);
+        void save_file(cereal::PortableBinaryOutputArchive& a) const;
+        void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version);
+        const std::unique_ptr<CanvasComponent>& get_comp();
+        const CoordSpaceHelper& get_coords();
+    private:
+        std::unique_ptr<CanvasComponent> allocate_comp(CanvasComponent::CompType type);
+        std::unique_ptr<CanvasComponent> comp;
+        CoordSpaceHelper coords;
+};

src/DrawingProgram/DrawingProgram.cpp

@@ -283,7 +283,7 @@ void DrawingProgram::tool_options_gui() {
     }
 }
 
-void DrawingProgram::modify_grid(const NetworkingObjects::NetObjPtr<WorldGrid>& gridToModify) {
+void DrawingProgram::modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& gridToModify) {
     std::unique_ptr<GridModifyTool> newTool(std::make_unique<GridModifyTool>(*this));
     newTool->set_grid(gridToModify);
     switch_to_tool_ptr(std::move(newTool));

src/DrawingProgram/DrawingProgram.hpp

@@ -2,7 +2,7 @@
 #include "../DrawData.hpp"
 #include "DrawingProgramCache.hpp"
 #include "GridModifyTool.hpp"
-#include <Helpers/NetworkingObjects/NetObjPtr.hpp>
+#include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp>
 #include "PanCanvasTool.hpp"
 #include "ZoomCanvasTool.hpp"
 #include "cereal/archives/portable_binary.hpp"
@@ -64,7 +64,7 @@ class DrawingProgram {
 
         void clear_draw_cache();
 
-        void modify_grid(const NetworkingObjects::NetObjPtr<WorldGrid>& gridToModify);
+        void modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& gridToModify);
 
     private:
         std::optional<std::chrono::steady_clock::time_point> badFrametimeTimePoint;

src/DrawingProgram/GridModifyTool.cpp

@@ -3,6 +3,7 @@
 #include "../MainProgram.hpp"
 #include "../DrawData.hpp"
 #include "Helpers/Networking/NetLibrary.hpp"
+#include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp"
 #include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp>
 #include <Helpers/NetworkingObjects/NetObjGenericSerializedClass.hpp>
 #include <cstddef>
@@ -14,10 +15,11 @@ GridModifyTool::GridModifyTool(DrawingProgram& initDrawP):
 {
 }
 
-void GridModifyTool::set_grid(const NetObjPtr<WorldGrid>& newGrid) {
+void GridModifyTool::set_grid(const NetObjWeakPtr<WorldGrid>& newGrid) {
     grid = newGrid;
-    if(drawP.world.gridMan.grids->contains(grid)) {
-        WorldGrid& g = *grid;
+    NetworkingObjects::NetObjTemporaryPtr<WorldGrid> gLock = grid.lock();
+    if(gLock) {
+        WorldGrid& g = *gLock;
         oldGrid = g;
         CoordSpaceHelper newCam;
         newCam.inverseScale = g.size / WorldScalar(WorldGrid::GRID_UNIT_PIXEL_SIZE);
@@ -35,8 +37,9 @@ void GridModifyTool::gui_toolbox() {
     Toolbar& t = drawP.world.main.toolbar;
     t.gui.push_id("Grid modify tool");
     t.gui.text_label_centered("Edit Grid");
-    if(drawP.world.gridMan.grids->contains(grid)) {
-        WorldGrid& g = *grid;
+    NetworkingObjects::NetObjTemporaryPtr<WorldGrid> gLock = grid.lock();
+    if(gLock) {
+        WorldGrid& g = *gLock;
         t.gui.input_text_field("grid name", "Name", &g.name);
         t.gui.checkbox_field("Visible", "Visible", &g.visible);
         t.gui.checkbox_field("Display in Front", "Display in front of canvas", &g.displayInFront);
@@ -86,8 +89,9 @@ bool GridModifyTool::right_click_popup_gui(Vector2f popupPos) {
 }
 
 void GridModifyTool::tool_update() {
-    if(drawP.world.gridMan.grids->contains(grid)) {
-        WorldGrid& g = *grid;
+    NetworkingObjects::NetObjTemporaryPtr<WorldGrid> gLock = grid.lock();
+    if(gLock) {
+        WorldGrid& g = *gLock;
         switch(selectionMode) {
             case 0:
                 if(drawP.controls.leftClick) {
@@ -137,7 +141,7 @@ void GridModifyTool::tool_update() {
                     selectionMode = 0;
                 break;
         }
-        drawP.world.delayedUpdateObjectManager.send_update_to_all<WorldGrid>(grid, false);
+        drawP.world.delayedUpdateObjectManager.send_update_to_all<WorldGrid>(gLock, false);
     }
     else
         selectionMode = 0;
@@ -148,8 +152,9 @@ bool GridModifyTool::prevent_undo_or_redo() {
 }
 
 void GridModifyTool::draw(SkCanvas* canvas, const DrawData& drawData) {
-    if(drawP.world.gridMan.grids->contains(grid)) {
-        WorldGrid& g = *grid;
+    NetworkingObjects::NetObjTemporaryPtr<WorldGrid> gLock = grid.lock();
+    if(gLock) {
+        WorldGrid& g = *gLock;
         if(g.bounds.has_value()) {
             const auto& b = g.bounds.value();
             Vector2f bMin = drawP.world.drawData.cam.c.to_space(b.min);
@@ -180,5 +185,7 @@ void GridModifyTool::draw(SkCanvas* canvas, const DrawData& drawData) {
 }
 
 void GridModifyTool::switch_tool(DrawingProgramToolType newTool) {
-    drawP.world.delayedUpdateObjectManager.send_update_to_all<WorldGrid>(grid, true);
+    NetworkingObjects::NetObjTemporaryPtr<WorldGrid> gLock = grid.lock();
+    if(gLock)
+        drawP.world.delayedUpdateObjectManager.send_update_to_all<WorldGrid>(gLock, true);
 }

src/DrawingProgram/GridModifyTool.hpp

@@ -1,14 +1,14 @@
 #pragma once
 #include "DrawingProgramToolBase.hpp"
 #include "../WorldGrid.hpp"
-#include "Helpers/NetworkingObjects/NetObjPtr.hpp"
+#include "Helpers/NetworkingObjects/NetObjWeakPtr.hpp"
 
 class DrawingProgram;
 
 class GridModifyTool : public DrawingProgramToolBase {
     public:
         GridModifyTool(DrawingProgram& initDrawP);
-        void set_grid(const NetworkingObjects::NetObjPtr<WorldGrid>& newGrid);
+        void set_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& newGrid);
         virtual DrawingProgramToolType get_type() override;
         virtual void gui_toolbox() override;
         virtual bool right_click_popup_gui(Vector2f popupPos) override;
@@ -18,6 +18,6 @@ class GridModifyTool : public DrawingProgramToolBase {
         virtual void switch_tool(DrawingProgramToolType newTool) override;
     private:
         WorldGrid oldGrid;
-        NetworkingObjects::NetObjPtr<WorldGrid> grid;
+        NetworkingObjects::NetObjWeakPtr<WorldGrid> grid;
         unsigned selectionMode = 0;
 };

src/GridManager.cpp

@@ -21,32 +21,13 @@ void GridManager::add_default_grid(const std::string& newName) {
         g.color = color_mul_alpha(convert_vec4<Vector4f>(world.canvasTheme.toolFrontColor), 0.4f);
         g.size = world.drawData.cam.c.inverseScale * WorldScalar(WorldGrid::GRID_UNIT_PIXEL_SIZE);
         g.offset = world.drawData.cam.c.pos + world.drawData.cam.c.dir_from_space(world.main.window.size.cast<float>() * 0.5f);
-        NetworkingObjects::NetObjPtr<WorldGrid> gridPtr = grids->emplace_back_direct(grids, g);
-
-        uint32_t pos = grids->size() - 1;
-        world.undo.push({[&grids = grids, gridPtr](){
-            grids->erase(grids, gridPtr);
-            return true;
-        },
-        [&grids = grids, gridPtr, pos]() {
-            grids->insert_and_send_create(grids, pos, gridPtr);
-            return true;
-        }});
+        grids->emplace_back_direct(grids, g);
     }
 }
 
 void GridManager::remove_grid(uint32_t indexToRemove) {
-    if(grids) {
-        NetworkingObjects::NetObjPtr<WorldGrid> gridPtr = grids->erase(grids, indexToRemove);
-        world.undo.push({[&grids = grids, gridPtr, indexToRemove]() {
-            grids->insert_and_send_create(grids, indexToRemove, gridPtr);
-            return true;
-        },
-        [&grids = grids, gridPtr](){
-            grids->erase(grids, gridPtr);
-            return true;
-        }});
-    }
+    if(grids)
+        grids->erase(grids, indexToRemove);
 }
 
 void GridManager::draw_back(SkCanvas* canvas, const DrawData& drawData) {

src/GridManager.hpp

@@ -1,7 +1,7 @@
 #pragma once
-#include "Helpers/NetworkingObjects/NetObjPtr.decl.hpp"
 #include "WorldGrid.hpp"
 #include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
+#include <Helpers/NetworkingObjects/NetObjOwnerPtr.hpp>
 
 class World;
 
@@ -33,6 +33,6 @@ class GridManager {
         void draw_coordinates(SkCanvas* canvas, const DrawData& drawData);
         void scale_up(const WorldScalar& scaleUpAmount);
 
-        NetworkingObjects::NetObjPtr<NetworkingObjects::NetObjOrderedList<WorldGrid>> grids;
+        NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<WorldGrid>> grids;
         World& world;
 };

src/MainProgram.cpp

@@ -38,8 +38,6 @@
 #endif
 
 #include <Helpers/Logger.hpp>
-#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
-#include <Helpers/NetworkingObjects/NetObjGenericSerializedClass.hpp>
 
 MainProgram::MainProgram():
     fonts(std::make_shared<FontData>()),

src/World.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include "Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp"
-#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
+#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
+#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
 #include "UndoManager.hpp"
 #include "BookmarkManager.hpp"
 #include "ResourceManager.hpp"