CanvasLib.hpp

#pragma once
 
#include <functional>
#include <memory>
#include <string>
 
#include "CanvasLib/Color.hpp"
#include "CanvasLib/Colors.hpp"
#include "CanvasLib/Vec2.hpp"
#include <GLFW/glfw3.h>
#include <RenderAbstraction.hpp>
#include <glad/glad.h>
 
#define CANVASLIB_EXPORT
 
namespace canv
{
 
class CANVASLIB_EXPORT Canvas
{
public:
    enum class DrawMode
    {
        Fill,
        Outline
    };
 
    Canvas(const Canvas&) = delete;
    Canvas(Canvas&&) = delete;
    auto operator=(const Canvas&) -> Canvas& = delete;
    auto operator=(Canvas&&) -> Canvas& = delete;
 
    Canvas(uint32_t width, uint32_t height);
    ~Canvas();
 
    void start();
    void setUpdateFunction(std::function<void(double)> upd);
 
    void drawRectangle(float x, float y, float w, float h);
 
    void drawEllipse(float cx, float cy, float rx, float ry, int segments = 40);
 
    void setFillColor(const Color& color);
 
    void setDrawMode(const DrawMode& drawMode);
 
    static void enableWatches();
    static void disableWatches();
    static void setWatch(const std::string& key, const std::string& value);
    static void removeWatch(const std::string& key);
 
private:
    [[nodiscard]] auto _xToGl(float x) const -> float;
    [[nodiscard]] auto _yToGl(float y) const -> float;
    [[nodiscard]] auto _normalizeSizeGl(const Vec2f& size) const -> Vec2f;
 
    static void renderWatches();
    static bool s_ShouldRenderWatches;
    static std::unique_ptr<std::thread> s_WatchesRenderThread;
    static std::mutex s_CustomWatchesMutex;
    static std::unordered_map<std::string, std::string> s_CustomWatches;
 
    void applyColorGl() const;
 
    std::unique_ptr<Ra::Window> m_Window;
    std::function<void(double)> m_UpdateFunction;
    Color m_FillColor;
    Ra::RendererAPI::DrawMode m_DrawMode;
    Vec2<uint32_t> m_Size;
    glm::mat4 m_Projection;
    double m_LastFrameTime;
};
 
} // namespace canv