学习opengl之制作魔方

最新推荐文章于 2024-01-16 20:15:23 发布

原创最新推荐文章于 2024-01-16 20:15:23 发布 · 置顶 · 3.5k 阅读

35 ·

CC 4.0 BY-SA版权

opengl 专栏收录该内容

3 篇文章

订阅专栏

效果

实现了一个魔方能够按照某一边旋转，但本内容没有过多考虑纹理，所以魔方内部也有颜色。
在这里插入图片描述

工具

glad、glfw(这个无所谓)、glm（这个也主要是为了和glad配合，使用eigen也行）

思路

状态机
- STOP 停止不动时如何刷新界面
- RUNX(Y/Z) 沿着X/Y/Z轴旋转时如何作图
- UPDATE 当旋转到位置时，更新模型矩阵，包括旋转以及位置
UPDATE状态中更新旋转矩阵
每一个小块（27块）都有专门为其设置的姿态矩阵model，每次旋转之后，记录一个块的旋转矩阵（表明颜色的翻转）

gl_Position = projection * view * model * vec4(aPos, 1.0f);

RUN状态中更新每一个块的位置，更新对象的旋转与model的构建过程有关。更新对象魏 model*Vec(aPos,1.f)的三维坐标中符合要求的值。
如我们希望让下面的那一层转（这个是y轴负方向），因为我们应该更新那些三维坐标位于 y=1的位置的块，写出来就是

model*Vec(aPos,1) . y() ==1 //希望这些块被选中。

代码

main.cpp
着色器相关
main.cpp

#pragma execution_character_set("utf-8")
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include "shader_m.h"

#include <iostream>
#include <string>
#include <vector>
#include <Eigen/Eigen>
#include <mutex>
using namespace std;
using namespace Eigen;
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);
void Eigen3Eigen4(Eigen::Matrix3f m3, Eigen::Matrix4f& m4);
void Eigen4Eigen3(Eigen::Matrix4f m4, Eigen::Matrix3f& m3);
void Eigen2glm(Eigen::Matrix4f e, glm::mat4& g);
void show(glm::mat4 m);
void showmodel(glm::mat4 m);

// settings
const unsigned int SCR_WIDTH = 400;
const unsigned int SCR_HEIGHT = 400;
// camera
glm::vec3 cameraPos = glm::vec3(5.f, 5.f, 5.0f);
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);

//整体旋转使用
float deltaalpha = 0.f;
float deltabeta = 0.f;
float deltatheta = 0.f; //左右转

//测试某一层旋转所用, 如果我知道了每一个块的最初编号。
double alltime = 0;
int axis =-1;
float angle = 0;
float targetangle = 90;
glm::vec3 axisVec;
mutex axismutex;

glm::mat4 currentModel = glm::mat4(1.0f);
vector<glm::mat4> allMats(27, glm::mat4(1.f));
glm::mat4 world = glm::mat4(1.f);


// timing
float deltaTime = 0.0f;	// time between current frame and last frame
float lastFrame = 0.0f;

enum State
{
    STOP,
    RUNX,
    RUNY,
    RUNZ,
    UPDATE,
    OTHER
};
State state = STOP;

int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
#endif

    // glfw window creation
    // --------------------
    std::cout << "一个可以旋转的正方体（WASD，R）" << std::endl;
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "一个可以旋转的正方体（WASD，R）", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // configure global opengl state
    // -----------------------------
    glEnable(GL_DEPTH_TEST);

    // build and compile our shader zprogram
    // ------------------------------------
    Shader ourShader("cube.vs", "cube.fs");

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
        -0.5f, -0.5f, -0.5f,  
         0.5f, -0.5f, -0.5f, 
         0.5f,  0.5f, -0.5f, 
         0.5f,  0.5f, -0.5f,  
        -0.5f,  0.5f, -0.5f,  
        -0.5f, -0.5f, -0.5f, 

        -0.5f, -0.5f,  0.5f, 
         0.5f, -0.5f,  0.5f,
         0.5f,  0.5f,  0.5f, 
         0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f,  0.5f,
        -0.5f, -0.5f,  0.5f, 

        -0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f, -0.5f,  
        -0.5f, -0.5f, -0.5f, 
        -0.5f, -0.5f, -0.5f, 
        -0.5f, -0.5f,  0.5f, 
        -0.5f,  0.5f,  0.5f, 

         0.5f,  0.5f,  0.5f, 
         0.5f,  0.5f, -0.5f, 
         0.5f, -0.5f, -0.5f,  
         0.5f, -0.5f, -0.5f, 
         0.5f, -0.5f,  0.5f, 
         0.5f,  0.5f,  0.5f, 

        -0.5f, -0.5f, -0.5f, 
         0.5f, -0.5f, -0.5f, 
         0.5f, -0.5f,  0.5f, 
         0.5f, -0.5f,  0.5f, 
        -0.5f, -0.5f,  0.5f,  
        -0.5f, -0.5f, -0.5f, 

        -0.5f,  0.5f, -0.5f, 
         0.5f,  0.5f, -0.5f, 
         0.5f,  0.5f,  0.5f, 
         0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f, -0.5f, 

    };

    float yanse[] = {
        //白色
        1.f,1.f,1.f,
        1.f,1.f,1.f,
        1.f,1.f,1.f,
        1.f,1.f,1.f,
        1.f,1.f,1.f,
        1.f,1.f,1.f,

        //红色
        1.0f,0.f,0.f,
        1.0f,0.f,0.f,
        1.0f,0.f,0.f,
        1.0f,0.f,0.f,
        1.0f,0.f,0.f,
        1.0f,0.f,0.f,

        //绿色
        0.0f,1.f,0.f,
        0.0f,1.f,0.f,
        0.0f,1.f,0.f,
        0.0f,1.f,0.f,
        0.0f,1.f,0.f,
        0.0f,1.f,0.f,

        //蓝色
        0.0f,0.f,1.f,
        0.0f,0.f,1.f,
        0.0f,0.f,1.f,
        0.0f,0.f,1.f,
        0.0f,0.f,1.f,
        0.0f,0.f,1.f,

        //黑色
        0.f,0.f,0.f,
        0.f,0.f,0.f,
        0.f,0.f,0.f,
        0.f,0.f,0.f,
        0.f,0.f,0.f,
        0.f,0.f,0.f,

        //浅蓝
        0.f,1.f,1.f,
        0.f,1.f,1.f,
        0.f,1.f,1.f,
        0.f,1.f,1.f,
        0.f,1.f,1.f,
        0.f,1.f,1.f
    };

    // world space positions of our cubes
    glm::vec3 cubePositions[] = {
        glm::vec3(0.0f,0.0f,-1.f),
        glm::vec3(1.0f,0.f,-1.f),
        glm::vec3(0.f,1.f,-1.0f),
        glm::vec3(-1.f,0.f,-1.f),
        glm::vec3(0.f,-1.f,-1.0f),
        glm::vec3(1.f,1.f,-1.f),
        glm::vec3(-1.f,1.f,-1.0f),
        glm::vec3(-1.f,-1.f,-1.f),
        glm::vec3(1.f,-1.f,-1.0f),
        glm::vec3(0.0f,0.0f,0.0f),   //0
        glm::vec3(1.0f,0.f,0.f),
        glm::vec3(0.f,1.f,0.0f),
        glm::vec3(-1.f,0.f,0.f),
        glm::vec3(0.f,-1.f,0.0f),
        glm::vec3(1.f,1.f,0.f),
        glm::vec3(-1.f,1.f,0.0f),
        glm::vec3(-1.f,-1.f,0.f),
        glm::vec3(1.f,-1.f,0.0f),
        glm::vec3(0.0f,0.0f,1.f),
        glm::vec3(1.0f,0.f,1.f),
        glm::vec3(0.f,1.f,1.0f),
        glm::vec3(-1.f,0.f,1.f),
        glm::vec3(0.f,-1.f,1.0f),
        glm::vec3(1.f,1.f,1.f),
        glm::vec3(-1.f,1.f,1.0f),
        glm::vec3(-1.f,-1.f,1.f),
        glm::vec3(1.f,-1.f,1.0f)
    };
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // texture coord attribute
    unsigned int colorbuffer;
    glGenBuffers(1, &colorbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(yanse), yanse, GL_STATIC_DRAW);

    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(1);
    // tell opengl for each sampler to which texture unit it belongs to (only has to be done once)
    // -------------------------------------------------------------------------------------------
    ourShader.use();

    // pass projection matrix to shader (as projection matrix rarely changes there's no need to do this per frame)
    // -----------------------------------------------------------------------------------------------------------
    glm::mat4 projection = glm::perspective(glm::radians(45.f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    ourShader.setMat4("projection", projection);


    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        float currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;
        processInput(window);
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // activate shader
        ourShader.use();
        // camera/view transformation
        glm::mat4 view = glm::lookAt(cameraPos, glm::vec3(0.f,0.f,0.f), cameraUp);
        ourShader.setMat4("view", view);
        // calculate the model matrix for each object and pass it to shader before drawing
        currentModel = glm::rotate(currentModel, glm::radians(deltaalpha), glm::vec3(0.0f, 1.f, 0.f));
        currentModel = glm::rotate(currentModel, glm::radians(deltabeta), glm::vec3(1.0f, 0.f, 0.f));
        currentModel = glm::rotate(currentModel, glm::radians(deltatheta), glm::vec3(0.0f, 0.f, 1.f));

        glm::mat4 thismodel;
        Eigen::Matrix4f rotation;
        glm::mat4 before;
        switch (state)
        {
        case STOP:
        {
            for (int i = 0; i < 27; i++)
            {
                glm::mat4 hh = currentModel;
                hh *= allMats[i];
                thismodel = glm::translate(hh, cubePositions[i]);
                ourShader.setMat4("model", thismodel);
                glDrawArrays(GL_TRIANGLES, 0, 36);
            }
            if (axis == 0)
            {
                state = RUNX;
                angle = 0;
                axisVec = glm::vec3(1.f, 0.f, 0.f);
            }
            else if (axis == 1)
            {
                state = RUNY;
                angle = 0;
                axisVec = glm::vec3(0.f, 1.f, 0.f);
            }
            else if (axis == 2)
            {
                state = RUNZ;
                angle = 0;
                axisVec = glm::vec3(0.f, 0.f, 1.f);
            }
            break;
        }
        case RUNX:
        {
            angle += deltaTime /2 * targetangle;
            for (int i = 0; i < 27; i++)
            {
                glm::mat3 aya = allMats[i];
                glm::vec3 newcube = aya * cubePositions[i];
                float& x = newcube.x;
                if (x > -1.01f && x < -0.99f)
                {
                    glm::mat4 hh = glm::rotate(currentModel, glm::radians(angle), axisVec);
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                else
                {
                    glm::mat4 hh = currentModel;
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                ourShader.setMat4("model", thismodel);
                glDrawArrays(GL_TRIANGLES, 0, 36);

            }
            if (angle > targetangle)
            {
                state = UPDATE;
            }
            break;
        }
        case RUNY:
        {
            angle += deltaTime / 2 * targetangle;
            for (int i = 0; i < 27; i++)
            {
                glm::mat3 aya = allMats[i];
                glm::vec3 newcube = aya * cubePositions[i];
                float& y = newcube.y;
                if (y > -1.01f && y < -0.99f)
                {
                    glm::mat4 hh = glm::rotate(currentModel, glm::radians(angle), axisVec);
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                else
                {
                    glm::mat4 hh = currentModel;
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                ourShader.setMat4("model", thismodel);
                glDrawArrays(GL_TRIANGLES, 0, 36);
            }
            if (angle > targetangle)
            {
                state = UPDATE;
            }
            break;
        }
        case RUNZ:
        {
            angle += deltaTime / 2 * targetangle;
            for (int i = 0; i < 27; i++)
            {
                glm::mat3 aya = allMats[i];
                glm::vec3 newcube = aya * cubePositions[i];
                float& z = newcube.z;
                if (z > -1.01f && z < -0.99f)
                {
                    glm::mat4 hh = glm::rotate(currentModel, glm::radians(angle), axisVec);
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                else
                {
                    glm::mat4 hh = currentModel;
                    hh *= allMats[i];
                    thismodel = glm::translate(hh, cubePositions[i]);
                }
                ourShader.setMat4("model", thismodel);
                glDrawArrays(GL_TRIANGLES, 0, 36);
            }
            if (angle > targetangle)
            {
                state = UPDATE;
            }
            break;
        }
        case UPDATE:
        {
            //需要对axis变量上锁。
            unique_lock<mutex> lock(axismutex);
            for (int i = 0; i < 27; i++)
            {
                glm::mat3 aya = allMats[i];
                glm::vec3 newcube = aya * cubePositions[i];
                float& x = newcube.x;
                float& y = newcube.y;
                float& z = newcube.z;
                if (axis == 0)
                {
                    //cout << "update X" << endl;
                    if (x > -1.01f && x < -0.99f)
                    {
                        //先更新旋转
                        glm::mat4 thistime = glm::rotate(world, glm::radians(targetangle), glm::vec3(1.f, 0.f, 0.f));
                        allMats[i] = thistime * allMats[i];
                    }
                }
                else if (axis == 1)
                {
                    //cout << "update Y" << endl;
                    if (y > -1.01f && y < -0.99f)
                    {
                        glm::mat4 thistime = glm::rotate(world, glm::radians(targetangle), glm::vec3(0.f, 1.f, 0.f));
                        allMats[i] = thistime * allMats[i];
                    }
                }
                else if (axis == 2)
                {
                    //cout << "update Z" << endl;
                    if (z > -1.01f && z < -0.99f)
                    {
                        glm::mat4 thistime = glm::rotate(world, glm::radians(targetangle), glm::vec3(0.f, 0.f, 1.f));
                        allMats[i] = thistime * allMats[i];
                    }
                }
                else
                {
                    //否则没必要更新点了
                }
            }
            lock.unlock();
            for (int i = 0; i < 27; i++)
            {
                std::cout << "i th:" << i << " x,y,z: " << cubePositions[i].x << ' ' << cubePositions[i].y << ' ' << cubePositions[i].z << endl;
            }
            //更新完点之后，我再重新画这些点
            for (int i = 0; i < 27; i++)
            {
                glm::mat4 hh = currentModel;
                hh *= allMats[i];
                thismodel = glm::translate(hh, cubePositions[i]);
                ourShader.setMat4("model", thismodel);
                showmodel(thismodel);
                glDrawArrays(GL_TRIANGLES, 0, 36);
            }
            state = STOP;
            targetangle = 0;
            axis = -1;
            break;
        }
        }
        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    deltaalpha = 0;
    deltabeta = 0;
    deltatheta = 0;
    float cameraSpeed = 2.5 * deltaTime;
    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    {
        deltabeta -= 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    {
        deltabeta += 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    {
        deltaalpha -= 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    {
        deltaalpha += 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_J) == GLFW_PRESS)
    {
        deltatheta -= 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_K) == GLFW_PRESS)
    {
        deltatheta += 0.015f;
    }
    if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS)
    {
        currentModel = glm::mat4(1.0f);
    }
    if (glfwGetKey(window, GLFW_KEY_0) == GLFW_PRESS)
    {
        lock_guard<mutex> l(axismutex);
        axis = 0;
        targetangle = 90;
    }
    if (glfwGetKey(window, GLFW_KEY_1) == GLFW_PRESS)
    {
        lock_guard<mutex> l(axismutex);
        axis = 1;
        targetangle = 90;
    }
    if (glfwGetKey(window, GLFW_KEY_2) == GLFW_PRESS)
    {
        lock_guard<mutex> l(axismutex);
        axis = 2;
        targetangle = 90;
    }
}


// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

void Eigen3Eigen4(Eigen::Matrix3f m3, Eigen::Matrix4f& m4)
{
    m4 << m3(0), m3(1), m3(2), 0,
        m3(3), m3(4), m3(5), 0,
        m3(6), m3(7), m3(8), 0,
        0, 0, 0, 1;
}

void Eigen4Eigen3(Eigen::Matrix4f m4, Eigen::Matrix3f& m3)
{
    m3 << m4(0), m4(1), m4(2),
        m4(4), m4(5), m4(6),
        m4(8), m4(9), m4(10);
}

void Eigen2glm(Eigen::Matrix4f e, glm::mat4& g)
{
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            glm::value_ptr(g)[i * 4 + j] = e(i, j);
        }
    }
}

void show(glm::mat4 m)
{
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            cout << glm::value_ptr(m)[i * 4 + j] << ' ';
        }
        cout << endl;
    }
}

void showmodel(glm::mat4 m)
{
    std::cout << glm::value_ptr(m)[12] << ' ' << glm::value_ptr(m)[13] << ' ' << glm::value_ptr(m)[14] << endl;
}

cube.vs

#version 330 core

// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 vertexColor;

// Output data ; will be interpolated for each fragment.
out vec3 fragmentColor;


uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main(){	

	gl_Position = projection * view * model * vec4(aPos, 1.0f);

	fragmentColor = vertexColor;
}

cube.fs

#version 330 core

// Interpolated values from the vertex shaders
in vec3 fragmentColor;

// Ouput data
out vec3 color;

void main(){

	// Output color = color specified in the vertex shader, 
	// interpolated between all 3 surrounding vertices
	color = fragmentColor;

}