refactor layout.h into single file per Node* classes

engine/node_stroke_preview.cpp

@@ -0,0 +1,135 @@
+#include "pch.h"
+#include "log.h"
+#include "node_stroke_preview.h"
+#include "texture.h"
+#include "shader.h"
+#include "bezier.h"
+
+Node* NodeStrokePreview::clone_instantiate() const
+{
+    return new NodeStrokePreview();
+}
+
+void NodeStrokePreview::clone_copy(Node* dest) const
+{
+    NodeBorder::clone_copy(dest);
+}
+
+void NodeStrokePreview::clone_children(Node* dest) const
+{
+    // stop children cloning
+}
+
+void NodeStrokePreview::clone_finalize(Node* dest) const
+{
+    NodeStrokePreview* n = (NodeStrokePreview*)dest;
+    n->init_controls();
+}
+
+void NodeStrokePreview::init_controls()
+{
+    m_mesh.create();
+    m_sampler.create();
+    TextureManager::load("data/Icons/Round-Hard.png");
+    m_brush.m_tex_id = const_hash("data/Icons/Round-Hard.png");
+}
+
+void NodeStrokePreview::restore_context()
+{
+    NodeBorder::restore_context();
+    init_controls();
+    if (m_size.x > 0 && m_size.y > 0)
+        m_rtt.create(m_size.x, m_size.y);
+    draw_stroke();
+}
+
+void NodeStrokePreview::clear_context()
+{
+    NodeBorder::clear_context();
+    m_rtt.destroy();
+}
+
+void NodeStrokePreview::draw_stroke()
+{
+    m_rtt.bindFramebuffer();
+    {
+        using namespace ui;
+        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_rtt.getWidth(), m_rtt.getHeight());
+        glEnable(GL_BLEND);
+        glm::mat4 proj = glm::ortho<float>(0, (float)m_rtt.getWidth(), 0, (float)m_rtt.getHeight(), -1, 1);
+
+        m_stroke.reset();
+        m_stroke.start(m_brush);
+        auto samples = m_stroke.compute_samples();
+        auto& tex = TextureManager::get(m_brush.m_tex_id);
+        tex.bind();
+        m_sampler.bind(0);
+
+        if (true)
+        {
+            m_mesh.shader.use();
+            m_mesh.shader.u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+            m_mesh.shader.u_int(kShaderUniform::Tex, 0);
+            m_mesh.draw(samples, proj);
+        }
+        //else
+        //{
+        //    ShaderManager::use("stroke");
+        //    ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
+        //    ShaderManager::u_int(kShaderUniform::Tex, 0);
+        //    for (const auto& s : samples)
+        //    {
+        //        auto mvp = proj *
+        //            glm::translate(glm::vec3(s.pos, 0)) *
+        //            glm::scale(glm::vec3(s.size, s.size, 1)) *
+        //            glm::eulerAngleZ(s.angle);
+        //        ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+        //        ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
+        //        m_plane.draw_fill();
+        //    }
+        //}
+
+        m_sampler.unbind();
+        tex.unbind();
+        glDisable(GL_BLEND);
+
+        glViewport(vp[0], vp[1], vp[2], vp[3]);
+        glClearColor(cc[0], cc[1], cc[2], cc[3]);
+    }
+    m_rtt.unbindFramebuffer();
+}
+
+void NodeStrokePreview::draw()
+{
+    using namespace ui;
+    ui::ShaderManager::use(kShader::Texture);
+    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+    m_rtt.bindTexture();
+    m_sampler.bind(0);
+    m_plane.draw_fill();
+    m_sampler.unbind();
+    m_rtt.unbindTexture();
+}
+
+void NodeStrokePreview::handle_resize(glm::vec2 old_size, glm::vec2 new_size)
+{
+    float pad = 30.f;
+    float w = new_size.x;
+    float h = new_size.y;
+    std::vector<glm::vec2> kp = { { pad, pad },{ pad, h - pad },{ w - pad, pad },{ w - pad, h - pad } };
+    m_stroke.start(m_brush);
+    for (int i = 0; i < 20; i++)
+        m_stroke.add_point(BezierCurve::Bezier2D(kp, i / 20.f), 1.f);
+
+    m_rtt.destroy();
+    m_rtt.create((int)new_size.x, (int)new_size.y);
+    draw_stroke();
+}