#include "pch.h"
#include "node_colorwheel.h"
#include "shader.h"

Node* NodeColorWheel::clone_instantiate() const
{
    return new NodeColorWheel;
}

void NodeColorWheel::clone_finalize(Node* dest) const
{
    NodeColorWheel* n = (NodeColorWheel*)dest;
    n->init_controls();
}

void NodeColorWheel::init()
{
    //init_template("color-picker");
    init_controls();
}

void NodeColorWheel::init_controls()
{
}

void NodeColorWheel::loaded()
{
    m_circle.create<64>(.5, .4, ui::Circle::kUVMapping::Tube);
    m_cur_hue.create<16>(.05);
    
    struct vertex_t { glm::vec4 pos; glm::vec2 uvs; glm::vec4 col; };
    std::vector<vertex_t> vertices;
    float l = 0.4;
    vertices.push_back({{glm::cos(4.f/3.f*glm::pi<float>())*l,glm::sin(4.f/3.f*glm::pi<float>())*l,0,1},{1,-1},{1,1,1,1}});
    vertices.push_back({{glm::cos(2.f/3.f*glm::pi<float>())*l,glm::sin(2.f/3.f*glm::pi<float>())*l,0,1},{0,0},{0,0,0,1}});
    vertices.push_back({{l,0,0,1},{1,1},{1,0,0,1}});

    glGenBuffers(1, &buffers);
    glBindBuffer(GL_ARRAY_BUFFER, buffers);
    glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(vertex_t), vertices.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &arrays);
    glBindVertexArray(arrays);
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glEnableVertexAttribArray(2);
    glBindBuffer(GL_ARRAY_BUFFER, buffers);
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, uvs));
    glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(vertex_t), (GLvoid*)offsetof(vertex_t, col));
    glBindVertexArray(0);
}

void NodeColorWheel::draw()
{
    using namespace ui;
    
    glDisable(GL_BLEND);
    ShaderManager::use(kShader::ColorHue);
    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
    ShaderManager::u_int(kShaderUniform::Direction, 0); // set horizontal
    m_circle.draw_fill();

    ShaderManager::use(kShader::ColorTri);
    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
    ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
    GLenum type = GL_TRIANGLES;
    glBindVertexArray(arrays);
    glDrawArrays(type, 0, 3);
    glBindVertexArray(0);

    ShaderManager::use(kShader::Color);
    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::eulerAngleZ(glm::radians(360.f * m_hsv.x)) * glm::translate(glm::vec3(.45,0,0)));
    ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
    m_cur_hue.draw_stroke();
}