Renderive/Core/architecture/Render_Data.h

#pragma once
#include "../base/Geometry.h"
#include "../base/Memory.h"
#include "../base/Object_Semantics.h"
#include "../event/Event.h"
#include "../event/Key_Event.h"
#include "../event/Pointer_Event.h"
#include "../event/Resize_Event.h"
#include "../event/Wheel_Event.h"
#include "Render_Config.h"
#include "Update_Completion.h"
#include "global.h"
#include <concepts>
#include <cstdint>
#include <memory>
#include <memory_resource>
#include <type_traits>
#include <utility>

namespace renderive {

class Canvas;
struct Render_Frame_Snapshot;
struct Renderable;

struct Input_Data {
    virtual ~Input_Data() = default;
    virtual void clear() {}
};

struct Latest_Input_Data : Input_Data {
    bool pending = false;

    void mark_latest_pushed() {
        pending = true;
    }

    void clear_latest() {
        pending = false;
    }
};

struct Render_State {
    virtual ~Render_State() = default;
    std::uint64_t version = 0;
};

struct Hit_Testable {
    virtual ~Hit_Testable() = default;
    virtual bool select_test(const PointF& pos) = 0;
};

struct Pointer_Interactive {
    virtual ~Pointer_Interactive() = default;
    virtual void mouse_press_event(const Pointer_Event& event) = 0;
    virtual void mouse_move_event(const Pointer_Event& event) = 0;
    virtual void mouse_release_event(const Pointer_Event& event) = 0;
};

struct Wheel_Interactive {
    virtual ~Wheel_Interactive() = default;
    virtual void wheel_event(const Wheel_Event& event) = 0;
};

struct Key_Press_Interactive {
    virtual ~Key_Press_Interactive() = default;
    virtual void key_press_event(const Key_Event& event) = 0;
};

struct Key_Release_Interactive {
    virtual ~Key_Release_Interactive() = default;
    virtual void key_release_event(const Key_Event& event) = 0;
};

struct Hover_Interactive {
    virtual ~Hover_Interactive() = default;
    virtual void set_hover_state(Point pos, bool active) = 0;
};

struct Render_Object_Owner : Move_Only {
    Render_Object_Owner() noexcept = default;

    Render_Object_Owner(void* pointer, std::pmr::memory_resource* resource, void (*destroy)(void*, std::pmr::memory_resource*)) noexcept
        : pointer(pointer), resource(resource), destroy(destroy) {}

    Render_Object_Owner(Render_Object_Owner&& other) noexcept
        : pointer(std::exchange(other.pointer, nullptr)),
          resource(std::exchange(other.resource, nullptr)),
          destroy(std::exchange(other.destroy, nullptr)) {}

    Render_Object_Owner& operator=(Render_Object_Owner&& other) noexcept {
        if (this == &other)
            return *this;
        reset();
        pointer = std::exchange(other.pointer, nullptr);
        resource = std::exchange(other.resource, nullptr);
        destroy = std::exchange(other.destroy, nullptr);
        return *this;
    }

    ~Render_Object_Owner() {
        reset();
    }

    template <typename T>
    T* get() const {
        return static_cast<T*>(pointer);
    }

    void reset() noexcept {
        if (!pointer)
            return;
        destroy(pointer, resource);
        pointer = nullptr;
        resource = nullptr;
        destroy = nullptr;
    }

    explicit operator bool() const noexcept {
        return pointer != nullptr;
    }

    void* pointer{};
    std::pmr::memory_resource* resource{};
    void (*destroy)(void*, std::pmr::memory_resource*){};
};

template <typename T, typename... Args>
Render_Object_Owner make_render_object(Args&&... args) {
    std::pmr::memory_resource* resource = memory_resource(Memory_Domain::Renderable);
    std::pmr::polymorphic_allocator<T> allocator(resource);
    T* pointer = allocator.allocate(1);
    try {
        std::construct_at(pointer, std::forward<Args>(args)...);
    }
    catch (...) {
        allocator.deallocate(pointer, 1);
        throw;
    }
    return Render_Object_Owner(pointer, resource, [](void* object, std::pmr::memory_resource* resource) {
        std::pmr::polymorphic_allocator<T> allocator(resource);
        std::destroy_at(static_cast<T*>(object));
        allocator.deallocate(static_cast<T*>(object), 1);
    });
}

struct Render_State_Read_Handle {
    virtual ~Render_State_Read_Handle() = default;
};

struct Render_State_Edit_Handle {
    virtual ~Render_State_Edit_Handle() = default;
};

struct Render_Input_Edit_Handle {
    virtual ~Render_Input_Edit_Handle() = default;
    virtual void set_completion(std::shared_ptr<Update_State> state) {
        (void)state;
    }
};

struct Render_State_Read_Guard : Move_Only {
    Render_State_Read_Guard() = default;
    Render_State_Read_Guard(Render_State* state, std::unique_ptr<Render_State_Read_Handle> handle)
        : state(state), handle(std::move(handle)) {}
    Render_State_Read_Guard(Render_State_Read_Guard&&) noexcept = default;
    Render_State_Read_Guard& operator=(Render_State_Read_Guard&&) noexcept = default;
    ~Render_State_Read_Guard() = default;

    explicit operator bool() const noexcept {
        return state && handle;
    }

    Render_State* state{};
    std::unique_ptr<Render_State_Read_Handle> handle;
};

struct Render_State_Edit_Guard : Move_Only {
    Render_State_Edit_Guard() = default;
    Render_State_Edit_Guard(Render_State* state, std::unique_ptr<Render_State_Edit_Handle> handle)
        : state(state), handle(std::move(handle)) {}
    Render_State_Edit_Guard(Render_State_Edit_Guard&&) noexcept = default;
    Render_State_Edit_Guard& operator=(Render_State_Edit_Guard&&) noexcept = default;
    ~Render_State_Edit_Guard() = default;

    explicit operator bool() const noexcept {
        return state && handle;
    }

    Render_State* state{};
    std::unique_ptr<Render_State_Edit_Handle> handle;
};

struct Render_Input_Edit_Guard : Move_Only {
    Render_Input_Edit_Guard() = default;
    Render_Input_Edit_Guard(Input_Data* input, std::unique_ptr<Render_Input_Edit_Handle> handle)
        : input(input), handle(std::move(handle)) {}
    Render_Input_Edit_Guard(Render_Input_Edit_Guard&&) noexcept = default;
    Render_Input_Edit_Guard& operator=(Render_Input_Edit_Guard&&) noexcept = default;
    ~Render_Input_Edit_Guard() = default;

    explicit operator bool() const noexcept {
        return input && handle;
    }

    Input_Data* input{};
    std::unique_ptr<Render_Input_Edit_Handle> handle;

    void set_completion(std::shared_ptr<Update_State> state) {
        if (handle)
            handle->set_completion(std::move(state));
    }
};

enum class Renderable_State_Role : std::uint8_t {
    Edit,
    Ready,
    Render
};

enum class Renderable_Input_Role : std::uint8_t {
    Edit,
    Ready,
    Render
};

struct Render_Data {
    Renderable* q_ptr{};

    virtual void initialize_runtime(Renderable& owner, Renderable_Runtime_Strategy strategy) = 0;
    [[nodiscard]] virtual Renderable_Runtime_Strategy runtime_strategy() const = 0;
    virtual void cancel_pending_completions() = 0;
    virtual void drain_committed_update_states(std::pmr::vector<std::shared_ptr<Update_State>>& output) = 0;
    virtual Render_State_Read_Guard acquire_state_read(Renderable_State_Role role) = 0;
    virtual Render_State_Read_Guard acquire_render_state_read() = 0;
    virtual Render_State_Read_Guard acquire_edit_state_read() = 0;
    virtual Render_State_Read_Guard acquire_prepare_state_read() = 0;
    virtual Render_State_Edit_Guard acquire_edit_state() = 0;
    virtual Render_Input_Edit_Guard acquire_edit_input(bool notify_render) = 0;
    virtual void sync_state_pipeline() = 0;
    virtual Render_State* state(Renderable_State_Role role) = 0;
    virtual Render_State* render_state() = 0;
    virtual Render_State* ready_state() = 0;
    virtual Render_State* edit_state() = 0;
    virtual Input_Data* input_data(Renderable_Input_Role role) = 0;
    virtual Input_Data* render_input_data() = 0;
    virtual Input_Data* edit_input_data() = 0;
    virtual ~Render_Data() = default;
    virtual void draw(Canvas& canvas, const Render_Frame_Snapshot& snapshot) {}
    virtual void prepare_data(const Render_Frame_Snapshot& snapshot) {
        sync_state_pipeline();
    }
    virtual Rect pixel_bounds(const Size& plot_size) {
        return {0, 0, plot_size.width, plot_size.height};
    }
protected:
    virtual void copy_render_state_object(Render_State& target, const Render_State& source) {
        target.version = source.version;
    }
};

struct Base_Render_Data : Render_Data {
    void initialize_runtime(Renderable&, Renderable_Runtime_Strategy) override {}
    [[nodiscard]] Renderable_Runtime_Strategy runtime_strategy() const override {
        return Renderable_Runtime_Strategy::Explicit;
    }
    void cancel_pending_completions() override {}
    void drain_committed_update_states(std::pmr::vector<std::shared_ptr<Update_State>>&) override {}
    Render_State_Read_Guard acquire_state_read(Renderable_State_Role) override {
        return {};
    }
    Render_State_Read_Guard acquire_render_state_read() override {
        return {};
    }
    Render_State_Read_Guard acquire_edit_state_read() override {
        return {};
    }
    Render_State_Read_Guard acquire_prepare_state_read() override {
        return {};
    }
    Render_State_Edit_Guard acquire_edit_state() override {
        return {};
    }
    Render_Input_Edit_Guard acquire_edit_input(bool) override {
        return {};
    }
    Render_State* state(Renderable_State_Role) override {
        return nullptr;
    }
    Render_State* render_state() override {
        return nullptr;
    }
    Render_State* ready_state() override {
        return nullptr;
    }
    Render_State* edit_state() override {
        return nullptr;
    }
    Input_Data* render_input_data() override {
        return nullptr;
    }
    Input_Data* edit_input_data() override {
        return nullptr;
    }
    Input_Data* input_data(Renderable_Input_Role) override {
        return nullptr;
    }
    void sync_state_pipeline() override {}
};

template <typename T>
concept Render_State_Type = std::derived_from<T, Render_State> && std::is_copy_assignable_v<T>;

template <typename T>
concept Input_Data_Type = std::derived_from<T, Input_Data>;

template <typename T>
concept Render_Data_Type = std::derived_from<T, Render_Data>;

} // namespace renderive