refactor layout.h into single file per Node* classes

engine/node_slider.cpp

@@ -0,0 +1,146 @@
+#include "pch.h"
+#include "log.h"
+#include "node_slider.h"
+#include "shader.h"
+
+Node* NodeSliderH::clone_instantiate() const
+{
+    return new NodeSliderH();
+}
+
+void NodeSliderH::clone_copy(Node* dest) const
+{
+    NodeBorder::clone_copy(dest);
+    NodeSliderH* n = static_cast<NodeSliderH*>(dest);
+    n->m_value = m_value;
+}
+
+void NodeSliderH::init()
+{
+    SetPadding(1, 1, 1, 1);
+    SetWidthP(100);
+    SetHeightP(100);
+    m_color = glm::vec4(1);
+}
+
+void NodeSliderH::draw()
+{
+    NodeBorder::draw();
+
+    using namespace ui;
+    auto sz = GetSize();
+    glm::vec2 cur_size = sz * (1.f - m_mask) + m_mask * glm::vec2(10);
+    glm::mat4 scale = glm::scale(glm::vec3(cur_size, 1.f));
+    glm::mat4 pos = glm::translate(glm::vec3(m_value * m_mask * sz + m_pos + sz * .5f * (1.f - m_mask), 0));
+    auto mvp = m_proj * pos * scale;
+
+    ui::ShaderManager::use(kShader::Color);
+    ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+    m_plane.draw_fill();
+}
+
+void NodeSliderH::set_value(float value)
+{
+    m_value = glm::vec2(value) * m_mask;
+    if (on_value_changed)
+        on_value_changed(this, glm::length(m_value));
+}
+
+float NodeSliderH::get_value()
+{
+    return glm::length(m_value);
+}
+
+void NodeSliderH::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* attr)
+{
+    NodeBorder::parse_attributes(ka, attr);
+    switch (ka)
+    {
+    case kAttribute::Value:
+        m_value = glm::vec2(attr->FloatValue());
+        break;
+    default:
+        break;
+    }
+}
+
+kEventResult NodeSliderH::handle_event(Event* e)
+{
+    NodeBorder::handle_event(e);
+    switch (e->m_type)
+    {
+    case kEventType::MouseDownL:
+        dragging = true;
+        mouse_capture();
+        {
+            auto sz = GetSize();
+            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz) * m_mask;
+            m_value = pos / glm::max({ 1, 1 }, sz);
+            if (on_value_changed)
+                on_value_changed(this, glm::length(m_value));
+        }
+        break;
+    case kEventType::MouseUpL:
+        mouse_release();
+        dragging = false;
+        break;
+    case kEventType::MouseMove:
+        if (dragging)
+        {
+            auto sz = GetSize();
+            auto pos = glm::clamp(((MouseEvent*)e)->m_pos - m_pos, { 0, 0 }, sz) * m_mask;
+            m_value = pos / glm::max({ 1, 1 }, sz);
+            if (on_value_changed)
+                on_value_changed(this, glm::length(m_value));
+        }
+        break;
+    default:
+        return kEventResult::Available;
+        break;
+    }
+    return kEventResult::Consumed;
+}
+
+Node* NodeSliderHue::clone_instantiate() const
+{
+    return new NodeSliderHue();
+}
+
+void NodeSliderHue::clone_finalize(Node* dest) const
+{
+    NodeSliderV::clone_finalize(dest);
+    NodeSliderHue* n = static_cast<NodeSliderHue*>(dest);
+    n->init_controls();
+}
+
+void NodeSliderHue::init()
+{
+    NodeSliderV::init();
+    init_controls();
+}
+
+void NodeSliderHue::init_controls()
+{
+    on_value_changed = [this](Node*, float value) {
+        m_color = glm::vec4(convert_hsv2rgb({ value, 1, 1 }), 1);
+        if (on_hue_changed)
+            on_hue_changed(this, m_color);
+    };
+}
+
+glm::vec4 NodeSliderHue::get_hue()
+{
+    return m_color;
+}
+
+void NodeSliderHue::draw()
+{
+    using namespace ui;
+    ui::ShaderManager::use(kShader::ColorHue);
+    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    //ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
+    m_plane.draw_fill();
+    NodeBorder::m_color = glm::vec4(0);
+    NodeSliderH::draw();
+}