Кубик Рубика, движение поясов

#include <GL/glew.h>
#include <GLFW/glfw3.h>
 
#define STRINGIFY(text) #text
//////////////////////////////////////////////////////////////////////////////////////////
// вершинный шейдер
const GLchar* vertex_shader_str = STRINGIFY
(
    #version 330 core\n
 
    layout(location = 0) in vec3 pos;
    layout(location = 1) in vec3 col;
    layout(location = 2) in mat4 model;
    
    uniform mat4 u_vp;
 
    out vec3 color;
 
    void main()
    {
        gl_Position = u_vp * model * vec4(pos, 1.0f);
        color = col;
    }
);
//////////////////////////////////////////////////////////////////////////////////////////
// фрагментный шейдер
const GLchar* fragment_shader_str = STRINGIFY
(
    #version 330 core\n
 
    in vec3 color;
 
    out vec4 frag_color;
 
    void main()
    {
        frag_color = vec4(color, 1.0f);
    }
);
//////////////////////////////////////////////////////////////////////////////////////////
static GLuint create_program(const char* vx_shader, const char* fr_shader)
{   // компиляция шейдера
    GLuint vx = glCreateShader(GL_VERTEX_SHADER);
    GLuint fr = glCreateShader(GL_FRAGMENT_SHADER);
 
    glShaderSource(vx, 1, &vx_shader, nullptr);
    glCompileShader(vx);
 
    glShaderSource(fr, 1, &fr_shader, nullptr);
    glCompileShader(fr);
 
    GLuint program = glCreateProgram();
    glAttachShader(program, vx);
    glAttachShader(program, fr);
    glLinkProgram(program);
 
    glDeleteShader(vx);
    glDeleteShader(fr);
 
    return program;
}
//////////////////////////////////////////////////////////////////////////////////////////
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "glm/gtc/type_ptr.hpp"
//////////////////////////////////////////////////////////////////////////////////////////
struct vertex
{   // вершина
    glm::vec3 pos;
    glm::vec3 col;
};
//////////////////////////////////////////////////////////////////////////////////////////
class animation // анимация вращения
{
    static constexpr float speed = 1.0f; // время поворота
    glm::quat m_start;  // начальное вращение
    glm::quat m_curr;   // интерполируемое вращение
    glm::quat m_end;    // конечное вращение
    float timer = 0;    // таймер
    bool finish = true; // анимация закончена
 
public:
 
    // запуск анимации (нормализованные кватернионы)
    void setup_ident(const glm::quat& start, const glm::quat& end)
    {
        m_start = start;
        m_end = end;
        float a = glm::dot(m_start, m_end);
        if (a < 0)
            m_curr = -m_end;
        else
            m_curr = m_end;
        m_curr -= m_start;
        finish = false;
    }
 
    // запуск анимации
    void setup(const glm::quat& start, const glm::quat& end)
    {
        setup_ident(glm::normalize(start), glm::normalize(end));
    }
 
    // интерполяция
    glm::quat interpolate(float dt)
    {
        timer += dt;
        if (timer >= speed)
        {
            finish = true;
            timer = 0;
            return m_end;
        }
        return glm::normalize(m_start + m_curr * timer);
    }
 
    bool is_done() { return finish; }
};
//////////////////////////////////////////////////////////////////////////////////////////
class transform // анимированная трансформация
{   
    glm::quat m_rot = glm::identity<glm::quat>();   // вращение
    glm::mat4 m_pos = glm::identity<glm::mat4>();   // положение в пространстве
    glm::mat4 m_transform = glm::identity<glm::mat4>(); // итоговая матрица
 
    bool need_update = false;   // флаг обновления
    animation m_anim;           // анимация вращения
 
public:
 
    // тик анимации
    bool update(float dt)
    {
        if (m_anim.is_done()) return false;
        m_rot = m_anim.interpolate(dt);
        need_update = true;
        return true;
    }
 
    // установка анимированного вращения
    void rotate(float angle, const glm::vec3& axis)
    {
        if (!m_anim.is_done()) return;
        m_anim.setup(m_rot, glm::rotate(m_rot, angle, glm::inverse(m_rot) * axis));
        need_update = true;
    }
 
    // установка положения
    void set_pos(const glm::vec3& pos)
    {
        m_pos = glm::translate(glm::identity<glm::mat4>(), pos);
        need_update = true;
    }
 
    // геттер матрицы модели
    const glm::mat4& get_transform()
    {
        if (need_update)
        {
            m_transform = glm::mat4(m_rot) * m_pos;
            need_update = false;
        }
        return m_transform;
    }
};
//////////////////////////////////////////////////////////////////////////////////////////
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////////
class Cubes // кубик рубик
{
public:
 
    // инициализация
    void init()
    {
/**********************
 *     7--------6
 *    /|       /|
 *   / |      / |
 *  3--------2  |
 *  |  |     |  |
 *  |  4-----|--5
 *  | /      | /
 *  |/       |/
 *  0--------1
 **********************/
        vertex data[]   // вершины модели
        {   //  позиция              |       цвет
            // 0, 1, 2
            {{-1.0f, -1.0f, 1.0f},      {1.0f, 0.0f, 0.0f}},
            {{1.0f, -1.0f, 1.0f},       {1.0f, 0.0f, 0.0f}},
            {{1.0f, 1.0f, 1.0f},        {1.0f, 0.0f, 0.0f}},
            // 0, 2, 3
            {{-1.0f, -1.0f, 1.0f},      {1.0f, 0.0f, 0.0f}},
            {{1.0f, 1.0f, 1.0f},        {1.0f, 0.0f, 0.0f}},
            {{-1.0f, 1.0f, 1.0f},       {1.0f, 0.0f, 0.0f}},
            // 1, 5, 6
            {{1.0f, -1.0f, 1.0f},       {1.0f, 1.0f, 0.0f}},
            {{1.0f, -1.0f, -1.0f},      {1.0f, 1.0f, 0.0f}},
            {{1.0f, 1.0f, -1.0f},       {1.0f, 1.0f, 0.0f}},
            // 1, 6, 2
            {{1.0f, -1.0f, 1.0f},       {1.0f, 1.0f, 0.0f}},
            {{1.0f, 1.0f, -1.0f},       {1.0f, 1.0f, 0.0f}},
            {{1.0f, 1.0f, 1.0f},        {1.0f, 1.0f, 0.0f}},
            // 5, 4, 7
            {{1.0f, -1.0f, -1.0f},      {0.0f, 1.0f, 0.0f}},
            {{-1.0f, -1.0f, -1.0f},     {0.0f, 1.0f, 0.0f}},
            {{-1.0f, 1.0f, -1.0f},      {0.0f, 1.0f, 0.0f}},
            // 5, 7, 6
            {{1.0f, -1.0f, -1.0f},      {0.0f, 1.0f, 0.0f}},
            {{-1.0f, 1.0f, -1.0f},      {0.0f, 1.0f, 0.0f}},
            {{1.0f, 1.0f, -1.0f},       {0.0f, 1.0f, 0.0f}},
            // 4, 0, 3
            {{-1.0f, -1.0f, -1.0f},     {0.0f, 1.0f, 1.0f}},
            {{-1.0f, -1.0f, 1.0f},      {0.0f, 1.0f, 1.0f}},
            {{-1.0f, 1.0f, 1.0f},       {0.0f, 1.0f, 1.0f}},
            // 4, 3, 7
            {{-1.0f, -1.0f, -1.0f},     {0.0f, 1.0f, 1.0f}},
            {{-1.0f, 1.0f, 1.0f},       {0.0f, 1.0f, 1.0f}},
            {{-1.0f, 1.0f, -1.0f},      {0.0f, 1.0f, 1.0f}},
            // 3, 2, 6
            {{-1.0f, 1.0f, 1.0f},       {0.0f, 0.0f, 1.0f}},
            {{1.0f, 1.0f, 1.0f},        {0.0f, 0.0f, 1.0f}},
            {{1.0f, 1.0f, -1.0f},       {0.0f, 0.0f, 1.0f}},
            // 3, 6, 7
            {{-1.0f, 1.0f, 1.0f},       {0.0f, 0.0f, 1.0f}},
            {{1.0f, 1.0f, -1.0f},       {0.0f, 0.0f, 1.0f}},
            {{-1.0f, 1.0f, -1.0f},      {0.0f, 0.0f, 1.0f}},
            // 4, 5, 1
            {{-1.0f, -1.0f, -1.0f},     {1.0f, 0.0f, 1.0f}},
            {{1.0f, -1.0f, -1.0f},      {1.0f, 0.0f, 1.0f}},
            {{1.0f, -1.0f, 1.0f},       {1.0f, 0.0f, 1.0f}},
            // 4, 1, 0
            {{-1.0f, -1.0f, -1.0f},     {1.0f, 0.0f, 1.0f}},
            {{1.0f, -1.0f, 1.0f},       {1.0f, 0.0f, 1.0f}},
            {{-1.0f, -1.0f, 1.0f},      {1.0f, 0.0f, 1.0f}},
        };
 
        // создаём буферы
        glGenVertexArrays(1, &vao);
        glGenBuffers(1, &vbo);
        glGenBuffers(1, &inst_data);
 
        // инициализируем буфер вершин
        glBindVertexArray(vao);
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (GLvoid*)offsetof(vertex, pos));
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (GLvoid*)offsetof(vertex, col));
 
        // для instance drawing
        glVertexAttribDivisor(0, 0);
        glVertexAttribDivisor(1, 0);
 
        // инициализируем буфер матриц для инстансов
        auto matrices = get_inst_data();
        constexpr size_t sz = sizeof(glm::mat4);
        constexpr size_t st = sizeof(glm::vec4);
 
        glBindBuffer(GL_ARRAY_BUFFER, inst_data);
        glBufferData(GL_ARRAY_BUFFER, sz * matrices.size(), matrices.data(), GL_STREAM_DRAW);
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sz, (GLvoid*)0);
        glEnableVertexAttribArray(3);
        glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sz, (GLvoid*)st);
        glEnableVertexAttribArray(4);
        glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, sz, (GLvoid*)(2 * st));
        glEnableVertexAttribArray(5);
        glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, sz, (GLvoid*)(3 * st));
 
        // для instanced drawing
        glVertexAttribDivisor(2, 1);
        glVertexAttribDivisor(3, 1);
        glVertexAttribDivisor(4, 1);
        glVertexAttribDivisor(5, 1);
 
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }
 
    ~Cubes()
    {
        glDeleteBuffers(1, &vbo);
        glDeleteBuffers(1, &inst_data);
        glDeleteVertexArrays(1, &vao);
    }
 
    void draw(GLuint shader, const glm::mat4& proj, const glm::mat4& view)
    {
        update_data();  // обновляем матрицы, если нужно
        glm::mat4 vp = proj * view ;    // ViewProjection матрица
 
        glUseProgram(shader);
 
        auto u_vp = glGetUniformLocation(shader, "u_vp");
        glUniformMatrix4fv(u_vp, 1, GL_FALSE, glm::value_ptr(vp));
 
        // рисуем инстансы
        glBindVertexArray(vao);
        glDrawArraysInstanced(GL_TRIANGLES, 0, 36, m_data.size());
        glBindVertexArray(0);
    }
 
    // поворот пояса
    void rotate_belt(int belt, int angle, int axis)
    {
        // belt - 0..2
        // 0 - ближний (проекция плоскости на ось вращения положительная)
        // 1 - средний
        // 2 - дальний
 
        // angle - -1 или 1 (влево, вправо)
 
        // axix - 0..2
        // 0 - ось x
        // 1 - ось y
        // 2 - ось z
        if (need_update) return;
        static const glm::vec3 ax[3]
        {
            {1, 0, 0},
            {0, 1, 0},
            {0, 0, 1}
        };
 
        constexpr float eps = 0.1f;
        const float coord = -(belt - 1) * offset;
        const float an = glm::radians(angle * 90.0f);
        for (auto&& tr : m_data)
        {
            if (std::abs(tr.get_transform()[3][axis] - coord) < eps)
            {    // если кубик в плоскости пояса
                tr.rotate(an, ax[axis]);
            }
        }
 
        need_update = true;
    }
 
    void update(float dt)
    {   // обновляем анимацию
        for (auto&& tr : m_data)
        {
            if (tr.update(dt) && !need_update)
                need_update = true;
        }
    }
 
private:
 
    static constexpr float offset = 2.1f; // смещение кубиков в пространстве
 
    std::vector<transform> generate()
    {   // начальная расстановка кубиков
        std::vector<transform> result;
        for (int x{ -1 }; x < 2; ++x)
        {
            for (int y{ -1 }; y < 2; ++y)
            {
                for (int z{ -1 }; z < 2; ++z)
                {
                    if (x == 0 && y == 0 && z == 0) continue;
                    result.push_back({});
                    result.back().set_pos({ x * offset, y * offset, z * offset });
                }
            }
        }
        return result;
    }
 
    std::vector<glm::mat4> get_inst_data()
    {   // копируем матрицы трансформаций, для последующей загрузки в буфер
        std::vector<glm::mat4> result;
        result.reserve(m_data.size());
        for (auto&& tr : m_data)
            result.push_back(tr.get_transform());
        return result;
    }
 
    void update_data()
    {   // если нужно, обновляем буфер матриц для инстансов
        if (need_update)
        {
            auto matrices = get_inst_data();
            constexpr size_t sz = sizeof(glm::mat4);
 
            glBindBuffer(GL_ARRAY_BUFFER, inst_data);
            glBufferSubData(GL_ARRAY_BUFFER, 0, sz * matrices.size(), matrices.data());
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            need_update = false;
        }
    }
 
private:
 
    bool need_update = false;   // флаг обновления буфера матриц для инстансов
 
    std::vector<transform> m_data = generate(); // вектор объектов кубиков(анимированных трансформаций)
 
    GLuint vbo; // буфер вершин
    GLuint vao; // массив атрибутов
    GLuint inst_data;   // буфер матриц
};
//////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
class App
{
public:
 
    static App& instance()
    {
        static App singleton{};
        return singleton;
    }
 
    int run()
    {
        if (!init()) return -1;
 
        glClearColor(0.2f, 0.5f, 0.8f, 1.0f);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
        glCullFace(GL_BACK);
 
        auto shader = create_program(vertex_shader_str, fragment_shader_str);
        glfwSetTime(0);
 
        while (!glfwWindowShouldClose(window))
        {
            obj.update(float(glfwGetTime()));
            glfwSetTime(0);
            glfwPollEvents();
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            obj.draw(shader, proj, view);
            glfwSwapBuffers(window);
        }
 
        glDeleteProgram(shader);
        return 0;
    }
 
    ~App() { if (ready) glfwTerminate(); }
 
private:
 
    inline static GLFWwindow* window = nullptr;
    inline static int width = 0;
    inline static int height = 0;
 
    glm::mat4 proj; // матрица перспективной проекции
    glm::mat4 view; // матрица вида
 
    bool ready{ false };
 
    inline static Cubes obj;
 
private:
 
    App() {};
    App(const App&) = delete;
    App& operator=(const App&) = delete;
 
    bool init()
    {
        if (ready) return ready;
        if (!glfwInit())
        {
            std::cout << "Failed to initialize GLFW" << std::endl;
            glfwTerminate();
            return false;
        };
 
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
 
        window = glfwCreateWindow(800, 600, "TestOpenGL", nullptr, nullptr);
        if (window == nullptr)
        {
            std::cout << "Failed to create GLFW window" << std::endl;
            glfwTerminate();
            return false;
        }
 
        glfwMakeContextCurrent(window);
        glfwSetKeyCallback(window, key_cb);
 
        glewExperimental = GL_TRUE;
        if (glewInit() != GLEW_OK)
        {
            std::cout << "Failed to initialize GLEW" << std::endl;
            glfwTerminate();
            return false;
        }
 
        glfwSwapInterval(1);
        glfwGetFramebufferSize(window, &width, &height);
        glViewport(0, 0, width, height);
 
        proj = glm::perspective(glm::radians(45.0f), (float)width / height, 0.1f, 1000.0f);
        view = glm::lookAt(glm::vec3{ 10, 10, 20 }, glm::vec3{ 0,0,0 }, glm::vec3{ 0,1,0 });
        obj.init();
 
        return ready = true;
    }
 
    static void key_cb(GLFWwindow*, int key, int, int action, int)
    {
        if (action != GLFW_PRESS) return;
        static int belt = 0;
        switch (key)
        {
        case GLFW_KEY_Q:    // против часовой вокруг оси z
            obj.rotate_belt(belt, 1, 2);
            break;
        case GLFW_KEY_E:    // по часовой вокруг оси z
            obj.rotate_belt(belt, -1, 2);
            break;
        case GLFW_KEY_A:    // по часовой вокруг оси y
            obj.rotate_belt(belt, -1, 1);
            break;
        case GLFW_KEY_D:    // против часовой вокруг оси y
            obj.rotate_belt(belt, 1, 1);
            break;
        case GLFW_KEY_W:    // по часовой вокруг оси x
            obj.rotate_belt(belt, -1, 0);
            break;
        case GLFW_KEY_S:    // против часовой вокруг оси x
            obj.rotate_belt(belt, 1, 0);
            break;
        case GLFW_KEY_KP_1: // выбираем ближний пояс
            belt = 0;
            break;
        case GLFW_KEY_KP_2: // выбираем средний пояс
            belt = 1;
            break;
        case GLFW_KEY_KP_3: // выбираем дальний пояс
            belt = 2;
            break;
        }
    }
};
//////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    return App::instance().run();
}