added Canvas, Brush, Stroke and CanvasNode classes

engine/canvas.h

@@ -0,0 +1,147 @@
+#pragma once
+#include "rtt.h"
+#include "texture.h"
+#include "shader.h"
+#include "shape.h"
+
+NS_START
+
+class Brush
+{
+public:
+    std::string m_name;
+    int id;
+    uint16_t m_texture_id;
+};
+
+class Stroke
+{
+public:
+    struct Keypoint
+    {
+        glm::vec2 pos;
+        float pressure;
+    };
+    int m_layer;
+    float m_dist;
+    std::shared_ptr<Brush> m_brush;
+    std::vector<Keypoint> m_keypoints;
+    void add_point(glm::vec2 pos, float pressure)
+    {
+        m_keypoints.emplace_back();
+        m_keypoints.back().pos = pos;
+        m_keypoints.back().pressure = pressure;
+    }
+};
+
+class Layer
+{
+public:
+    RTT m_rtt;
+    bool m_visible = true;
+    bool m_locked = false;
+    float m_alpha = 1.f;
+    std::string m_name;
+    bool create(int width, int height, std::string name)
+    {
+        m_rtt.create(width, height);
+        return true;
+    }
+};
+
+class Canvas
+{
+public:
+    int m_width;
+    int m_height;
+    std::vector<Layer> m_layers;
+    std::vector<Stroke> m_strokes;
+    std::unique_ptr<Layer> m_tmp;
+    Stroke* m_current_stroke = nullptr;
+    int m_current_layer_idx = 0;
+    RTT m_fb;
+    Sampler m_sampler;
+    Plane m_plane;
+    bool create(int width, int height) 
+    {
+        m_width = width;
+        m_height = height;
+        m_tmp = std::make_unique<Layer>();
+        m_tmp->create(width, height, "tmp");
+        m_fb.create(width, height);
+        m_sampler.create();
+        m_plane.create<1>(1, 1);
+        return true;
+    }
+    void layer_add(std::string name)
+    {
+        m_layers.emplace_back();
+        m_layers.back().create(m_width, m_height, name);
+    }
+    void stroke_start(glm::vec2 point, float pressure, std::shared_ptr<Brush> brush)
+    {
+        m_strokes.emplace_back();
+        m_strokes.back().m_brush = brush;
+        m_strokes.back().add_point(point, pressure);
+        m_current_stroke = &m_strokes.back();
+    }
+    void stroke_update(glm::vec2 point, float pressure)
+    {
+        m_current_stroke->add_point(point, pressure);
+
+        m_fb.bindFramebuffer();
+
+        GLint vp[4];
+        GLfloat cc[4];
+        glGetIntegerv(GL_VIEWPORT, vp);
+        glGetFloatv(GL_COLOR_CLEAR_VALUE, cc);
+
+        glViewport(0, 0, m_width, m_height);
+
+        auto mvp = glm::ortho(0.f, (float)m_width, (float)m_height, 0.f, -1.f, 1.f) *
+            glm::translate(glm::vec3(point, 0)) *
+            glm::scale(glm::vec3(30, 30, 1));
+
+        auto& tex = TextureManager::get(m_current_stroke->m_brush->m_texture_id);
+        tex.bind();
+        m_sampler.bind(0);
+        ui::ShaderManager::use(kShader::Texture);
+        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+        m_plane.draw_fill();
+        m_sampler.unbind();
+        tex.unbind();
+
+
+        glViewport(vp[0], vp[1], vp[2], vp[3]);
+        glClearColor(cc[0], cc[1], cc[2], cc[3]);
+
+        m_fb.unbindFramebuffer();
+    }
+    void stroke_end()
+    {
+        m_current_stroke = nullptr;
+    }
+    void clear()
+    {
+        m_fb.bindFramebuffer();
+
+        GLint vp[4];
+        GLfloat cc[4];
+        glGetIntegerv(GL_VIEWPORT, vp);
+        glGetFloatv(GL_COLOR_CLEAR_VALUE, cc);
+
+        glClearColor(1, 1, 1, 1);
+        glClear(GL_COLOR_BUFFER_BIT);
+        glViewport(0, 0, m_width, m_height);
+
+        //
+
+        glViewport(vp[0], vp[1], vp[2], vp[3]);
+        glClearColor(cc[0], cc[1], cc[2], cc[3]);
+
+        m_fb.unbindFramebuffer();
+    }
+};
+
+NS_END