c++ - OpenGL 简单立方体未出现，使用统一 block-6ren

c++ - OpenGL 简单立方体未出现，使用统一 block

转载作者：行者123 更新时间：2023-11-28 06:37:16

我正在尝试为类作业绘制一个简单的立方体，但由于某种原因它没有出现。

我正在使用统一 block 和现代 OpenGL。我确定我做的事情不正确。

我的完整代码如下。下面的例子依赖于 GLEW + GLFW + GLM。

我发现有趣的是，对于我的灯光和 Material 统一 block ，我得到了索引，但我的 MVP 矩阵的统一 block 我没有得到索引。

有什么想法吗？

C++代码如下:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>

#ifndef OPENGL_INCLUDES_
#define OPENGL_INCLUDES_

#include "GL\glew.h"

#ifndef GLFW_INCLUDES_
#define GLFW_INCLUDES_

#if defined(_WIN32)
#include <Windows.h>
#define GLFW_EXPOSE_NATIVE_WIN32
#define GLFW_EXPOSE_NATIVE_WGL
#elif defined(__linux__)
#include <X11/X.h>
#include <X11/extensions/Xrandr.h>
#define GLFW_EXPOSE_NATIVE_X11
#define GLFW_EXPOSE_NATIVE_GLX
#endif

#include "GLFW\glfw3.h"
#include "GLFW\glfw3native.h"

#endif

#endif

#ifndef GLM_INCLUDES_
#define GLM_INCLUDES_

#include <glm/glm.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>

#endif

GLFWwindow* MainWindow;

#ifdef _WIN32

HWND MainWindowWin32Handle;

#endif

GLint WindowWidth = 1024;
GLint WindowHeight = 768;

GLulong SizeDivizor = 1;

GLboolean RiftAvailable = false;
GLboolean UseApplicationWindowFrame = false;

GLuint MainOpenGLShaderProgramID;
GLuint MatricesUniformBlockID;
GLuint MatricesUniformBufferID;

GLuint LightsUniformBlockID;
GLuint LightsUniformBufferID;

GLuint MaterialsUniformBlockID;
GLuint MaterialsUniformBufferID;

glm::mat4 ViewMatrix;
glm::mat4 ViewModelMatrix;
glm::mat4 ProjectionMatrix;
glm::mat4 MVPMatrix;
glm::mat3 NormalMatrix;

class StandardCube;

std::vector<StandardCube> Cubes;

class StandardCube {

private:

    GLfloat* Vertices;
    GLfloat* Normals;
    GLuint* Indices;

    GLuint VAO;

    glm::mat4 ModelMatrix;

public:

    void LoadIntoOpenGL() {

        Vertices = new GLfloat[72]

        {
            1.0f, 1.0f, 1.0f,
            -1.0f, 1.0f, 1.0f,
            -1.0f, -1.0f, 1.0f,
            1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f, -1.0f,
            -1.0f, 1.0f, -1.0f,
            1.0f, 1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, 1.0f, 1.0f,
            1.0f, 1.0f, -1.0f,
            -1.0f, 1.0f, -1.0f,
            -1.0f, 1.0f, 1.0f,
            -1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, 1.0f,
            -1.0f, -1.0f, 1.0f,
            1.0f, 1.0f, 1.0f,
            1.0f, -1.0f, 1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, 1.0f, -1.0f,
            -1.0f, -1.0f, -1.0f,
            -1.0f, -1.0f, 1.0f,
            -1.0f, 1.0f, 1.0f,
            -1.0f, 1.0f, -1.0f
        };

        Normals = new GLfloat[72] {
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, -1.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f
        };

        Indices = new GLuint[36] {0, 1, 2, 2, 3, 0,
            4, 5, 6, 6, 7, 4,
            8, 9, 10, 10, 11, 8,
            12, 13, 14, 14, 15, 12,
            16, 17, 18, 18, 19, 16,
            20, 21, 22, 22, 23, 20
        };

        glGenVertexArrays(1, &VAO);
        glBindVertexArray(VAO);

        GLuint MeshBufferID;
        glGenBuffers(1, &MeshBufferID);
        glBindBuffer(GL_ARRAY_BUFFER, MeshBufferID);

        GLuint TotalBufferData = (sizeof(GLfloat) * 72) + (sizeof(GLfloat) * 72);

        glBufferData(GL_ARRAY_BUFFER, TotalBufferData, NULL, GL_STATIC_DRAW);

        glBufferSubData(GL_ARRAY_BUFFER, NULL, sizeof(GLfloat) * 72, Vertices);

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(0);

        glBufferSubData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 72, sizeof(GLfloat) * 72, Normals);

        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)(sizeof(GLfloat) * 72));
        glEnableVertexAttribArray(1);

        GLuint IndexBufferID;
        glGenBuffers(1, &IndexBufferID);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferID);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint) * 36, Indices, GL_STATIC_DRAW);

        glBindVertexArray(NULL);

        ModelMatrix = glm::mat4(1.0f);

    }

    void DrawMe() {

        MVPMatrix = ProjectionMatrix * ViewMatrix * ModelMatrix;
        ViewModelMatrix = ViewMatrix * ModelMatrix;
        NormalMatrix = glm::transpose(glm::inverse(glm::mat3(MVPMatrix)));

        glBindBuffer(GL_UNIFORM_BUFFER, MatricesUniformBufferID);

        glBufferSubData(GL_UNIFORM_BUFFER, NULL, sizeof(glm::mat4), glm::value_ptr(MVPMatrix));
        glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(ViewModelMatrix));
        glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) + sizeof(glm::mat4), sizeof(glm::mat3), glm::value_ptr(NormalMatrix));

        glBindBuffer(GL_UNIFORM_BUFFER, NULL);

        glBindVertexArray(VAO);
        glDrawElementsInstanced(GL_TRIANGLES, 36, GL_UNSIGNED_INT, NULL, 1);
        glBindVertexArray(NULL);

    }

};

static void GLFWKeyCallback(GLFWwindow* p_Window, GLint p_Key, GLint p_Scancode, GLint p_Action, GLint p_Mods) {

    if (p_Key == GLFW_KEY_ESCAPE && p_Action == GLFW_PRESS) {

        glfwSetWindowShouldClose(p_Window, GL_TRUE);
    }

    if (p_Key == GLFW_KEY_O && p_Action == GLFW_PRESS) {

        glClearColor(0.2f, 0.1f, 0.3f, 1.0f);

    }

    if (p_Key == GLFW_KEY_I && p_Action == GLFW_PRESS) {

        glClearColor(1.0f, 0.5f, 0.5f, 1.0f);

    }

}

static void GLFWWindowResizeCallBack(GLFWwindow* p_Window, GLint width, GLint height) {

    //CurrentGLFWApplication->WindowResizeCallBack(p_Window, width, height);

}

static void GLFWMouseMovementCallBack(GLFWwindow* p_Window, GLdouble MouseX, GLdouble MouseY) {

    //CurrentGLFWApplication->MouseMovementCallBack(p_Window, MouseX, MouseY);

}

static void GLFWFramebufferSizeCallback(GLFWwindow* window, GLint width, GLint height)
{

    glViewport(0, 0, width, height);

}

int initializeGLFWGLEW() {

    MainWindow = NULL;

    if (!glfwInit())
    {

        fprintf(stderr, "GLFW failed to initialize.");
        glfwTerminate();
        return EXIT_FAILURE;

    }

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_ANY_PROFILE);

    if (UseApplicationWindowFrame) {

        MainWindow = glfwCreateWindow(WindowWidth, WindowHeight, "Basic Oculus Rift Example", NULL, NULL);

    }
    else {

        if (!RiftAvailable) {

            MainWindow = glfwCreateWindow(WindowWidth, WindowHeight, "Basic Oculus Rift Example", NULL, NULL);

        }
        else {

            GLint MonitorCount;
            GLFWmonitor** GLFW_Monitors = glfwGetMonitors(&MonitorCount);
            GLFWmonitor* MonitorToUse;

            switch (MonitorCount)
            {
            case 0:
                printf("No monitors found, exiting.\n");
                return EXIT_FAILURE;
                break;
            case 1:
                printf("Two monitors expected, found only one, using primary...\n");
                MonitorToUse = glfwGetPrimaryMonitor();
                break;
            case 2:
                printf("Two monitors found, using second monitor\n");
                MonitorToUse = GLFW_Monitors[1];
                break;
            default:
                printf("More than two monitors found, using second monitor\n");
                MonitorToUse = GLFW_Monitors[1];
            }

            MainWindow = glfwCreateWindow(WindowWidth, WindowHeight, "Basic Oculus Rift Example", MonitorToUse, NULL);

        }

    }

    if (!MainWindow)
    {
        fprintf(stderr, "Could not determine OpenGL version; exiting.");
        glfwTerminate();
        return EXIT_FAILURE;
    }

    glfwMakeContextCurrent(MainWindow);

    glewExperimental = GL_TRUE;
    GLenum err = glewInit();

    if (GLEW_OK != err)
    {
        /* Problem: glewInit failed, something is seriously wrong. */
        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        return EXIT_FAILURE;

    }

    glfwSetInputMode(MainWindow, GLFW_STICKY_KEYS, GL_TRUE);

    glfwSetKeyCallback(MainWindow, GLFWKeyCallback);
    glfwSetWindowSizeCallback(MainWindow, GLFWWindowResizeCallBack);
    glfwSetCursorPosCallback(MainWindow, GLFWMouseMovementCallBack);
    glfwSetFramebufferSizeCallback(MainWindow, GLFWFramebufferSizeCallback);

    glfwSwapBuffers(MainWindow);

    glfwPollEvents();

    return EXIT_SUCCESS;

}

int prepareOpenGL() {

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glEnable(GL_CULL_FACE);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_MULTISAMPLE);

    return EXIT_SUCCESS;

}

int loadShaders() {

    // Create the shaders
    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

    // Compile Vertex Shader
    printf("Compiling Vertext Shader.\n\n");
    char const * VertexSource = "#version 330 \n\n\
        layout(std140) uniform MatrixInformation {\n\
            mat4 m_pvm;\n\
            mat4 m_viewModel;\n\
            mat3 m_normal;\n\
        };\n\
        layout(std140) uniform Lights {\n\
            vec3 l_dir; \n\
        };\n\
        in vec4 position;\n\
        in vec3 normal;\n\
        \n\
        \n\
        out Data{\n\
            vec3 normal;\n\
            vec4 eye;\n\
        } DataOut;\n\
        \n\
        void main() {\n\
            \n\
            DataOut.normal = normalize(m_normal * normal);\n\
            DataOut.eye = -(m_viewModel * position);\n\
            \n\
            gl_Position = m_pvm * position;\n\
        }\n\
    \n";

    glShaderSource(VertexShaderID, 1, &VertexSource, NULL);
    glCompileShader(VertexShaderID);

    // Check Vertex Shader

    GLint Result = GL_FALSE;
    int InfoLogLength;

    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);

    if (InfoLogLength > 0){

        std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1);
        glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
        std::string ErrorMessage = std::string(&VertexShaderErrorMessage[0]);
        printf("%s\n", &VertexShaderErrorMessage[0]);

    }

    printf("Compiling Fragment Shader.\n\n");
    char const * FragmentSource = "#version 330\n\
        layout(std140) uniform Materials {\n\
            vec4 diffuse;\n\
            vec4 ambient;\n\
            vec4 specular;\n\
            vec4 emissive;\n\
            float shininess;\n\
            int texCount;\n\
        };\
        \n\
        layout(std140) uniform Lights {\n\
            vec3 l_dir; \n\
        };\
        \n\
        in Data{\n\
            vec3 normal;\n\
            vec4 eye;\n\
        } DataIn;\n\
        \n\
        out vec4 colorOut;\
        \n\
        void main() {\n\
            \n\
            vec4 spec = vec4(0.0);\n\
            \n\
            vec3 n = normalize(DataIn.normal);\n\
            vec3 e = normalize(vec3(DataIn.eye));\n\
            \n\
            float intensity = max(dot(n, l_dir), 0.0);\n\
            \n\
            if (intensity > 0.0) {\n\
                vec3 h = normalize(l_dir + e);\n\
                \n\
                float intSpec = max(dot(h, n), 0.0);\n\
                spec = specular * pow(intSpec, shininess);\n\
            }\n\
        \n\
        colorOut = max(intensity *  diffuse + spec, ambient);\n\
    }";

    glShaderSource(FragmentShaderID, 1, &FragmentSource, NULL);
    glCompileShader(FragmentShaderID);

    // Check Fragment Shader
    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    if (InfoLogLength > 0){

        std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1);
        glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
        std::string ErrorMessage = std::string(&FragmentShaderErrorMessage[0]);
        printf("%s\n", &FragmentShaderErrorMessage[0]);

    }

    // Link the program
    printf("Linking shader program.\n\n");
    GLuint ProgramID = glCreateProgram();
    glAttachShader(ProgramID, VertexShaderID);
    glAttachShader(ProgramID, FragmentShaderID);
    glLinkProgram(ProgramID);

    // Check the program
    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    if (InfoLogLength > 0){

        std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
        glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
        std::string ErrorMessage = std::string(&ProgramErrorMessage[0]);
        printf("%s\n", &ProgramErrorMessage[0]);

    }

    glDeleteShader(VertexShaderID);
    glDeleteShader(FragmentShaderID);

    MainOpenGLShaderProgramID = ProgramID;

    return EXIT_SUCCESS;

}

int prepareShaderUniforms() {

    glUseProgram(MainOpenGLShaderProgramID);

    LightsUniformBlockID = glGetUniformBlockIndex(MainOpenGLShaderProgramID, "Lights");
    glUniformBlockBinding(MainOpenGLShaderProgramID, LightsUniformBlockID, 2);
    glGenBuffers(1, &LightsUniformBufferID);
    glBindBuffer(GL_UNIFORM_BUFFER, LightsUniformBufferID);
    glBindBufferBase(GL_UNIFORM_BUFFER, 2, LightsUniformBufferID);

    GLfloat LightDirection[3] = { 1.0f, 1.0f, 0.0f };

    glBufferData(GL_UNIFORM_BUFFER, sizeof(LightDirection), &LightDirection, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_UNIFORM_BUFFER, NULL);

    MatricesUniformBlockID = glGetUniformBlockIndex(MainOpenGLShaderProgramID, "MatrixInformation");
    glUniformBlockBinding(MainOpenGLShaderProgramID, MatricesUniformBlockID, 1);
    glGenBuffers(1, &MatricesUniformBufferID);
    glBindBuffer(GL_UNIFORM_BUFFER, MatricesUniformBufferID);
    glBindBufferBase(GL_UNIFORM_BUFFER, 1, MatricesUniformBufferID);
    GLsizeiptr TotalBufferSize = sizeof(glm::mat4) + sizeof(glm::mat4);
    TotalBufferSize += sizeof(glm::mat3);
    glBufferData(GL_ARRAY_BUFFER, TotalBufferSize, NULL, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_UNIFORM_BUFFER, NULL);

    MaterialsUniformBlockID = glGetUniformBlockIndex(MainOpenGLShaderProgramID, "Materials");
    glUniformBlockBinding(MainOpenGLShaderProgramID, MaterialsUniformBlockID, 3);
    glGenBuffers(1, &MaterialsUniformBufferID);
    glBindBuffer(GL_UNIFORM_BUFFER, MaterialsUniformBufferID);
    glBindBufferBase(GL_UNIFORM_BUFFER, 3, MaterialsUniformBufferID);

    GLfloat Material[18];

    //Diffuse
    Material[0] = 0.5f;
    Material[1] = 0.0f;
    Material[2] = 0.0f;
    Material[3] = 1.0f;

    //Ambient
    Material[4] = 0.2f;
    Material[5] = 0.2f;
    Material[6] = 0.2f;
    Material[7] = 1.0f;

    //Specular
    Material[8] = 0.0f;
    Material[9] = 0.0f;
    Material[10] = 0.0f;
    Material[11] = 1.0f;

    //Emissive
    Material[12] = 0.0f;
    Material[13] = 0.0f;
    Material[14] = 0.0f;
    Material[15] = 1.0f;

    //Shininess
    Material[16] = 2.0f;

    //Texture Count
    Material[17] = 0.0f;

    glBufferData(GL_UNIFORM_BUFFER, sizeof(Material), &Material, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_UNIFORM_BUFFER, NULL);

    return EXIT_SUCCESS;

}

int loadCubes() {

    StandardCube NewCube;

    NewCube.LoadIntoOpenGL();

    Cubes.push_back(NewCube);

    return EXIT_SUCCESS;

}

int prepareMatricies() {

    GLfloat AspectRatio = (GLfloat)(WindowWidth) / (GLfloat)(WindowHeight);

    ProjectionMatrix = glm::perspective(45.0f, AspectRatio, 1.0f, 1000.0f);

    ViewMatrix = glm::lookAt(
        glm::vec3(4.0f, 3.0f, 3.0f),        // camera is at (4,3,3), in world space - Where the camera is inside world.
        glm::vec3(0.0f, 0.0f, 0.0f),        // and looks at the origin - What point the camera is looking at inside world.
        glm::vec3(0.0f, 1.0f, 0.0f)// head is up(set to 0,1,0) - the direction of up for camera.
        );

    glViewport(0, 0, WindowWidth, WindowHeight);

    return EXIT_SUCCESS;

}

int main(int argc, char** argv) {

    if (initializeGLFWGLEW() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    if (prepareOpenGL() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    if (loadShaders() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    if (prepareShaderUniforms() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    if (loadCubes() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    if (prepareMatricies() == EXIT_FAILURE) {

        exit(EXIT_FAILURE);

    }

    while (!glfwWindowShouldClose(MainWindow))

    {

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        for (auto & C : Cubes) {

            C.DrawMe();

        }

        glfwSwapBuffers(MainWindow);

        glfwPollEvents();

    }

    exit(EXIT_SUCCESS);

}

这是我的顶点着色器:

#version 330 

layout(std140) uniform MatrixInformation {
    mat4 m_pvm;
    mat4 m_viewModel;
    mat3 m_normal;
};

layout(std140) uniform Lights {
    vec3 l_dir; 
};

in vec4 position;
in vec3 normal;

out Data{
    vec3 normal;
    vec4 eye;
} DataOut;

void main() {

    DataOut.normal = normalize(m_normal * normal);
    DataOut.eye = -(m_viewModel * position);

    gl_Position = m_pvm * position;
}

这是我的片段着色器:

#version 330
layout(std140) uniform Materials {

    vec4 diffuse;
    vec4 ambient;
    vec4 specular;
    vec4 emissive;
    float shininess;
    int texCount;

};  

layout(std140) uniform Lights {
    vec3 l_dir; 
};  

in Data{
    vec3 normal;
    vec4 eye;
} DataIn;

out vec4 colorOut;

void main() {

    vec4 spec = vec4(0.0);

    vec3 n = normalize(DataIn.normal);
    vec3 e = normalize(vec3(DataIn.eye));

    float intensity = max(dot(n, l_dir), 0.0);

    if (intensity > 0.0) {
        vec3 h = normalize(l_dir + e);

        float intSpec = max(dot(h, n), 0.0);
        spec = specular * pow(intSpec, shininess);
    }

    colorOut = max(intensity *  diffuse + spec, ambient);

}

最佳答案

所以问题是这部分:

//Binding uniform buffer
glBindBuffer(GL_UNIFORM_BUFFER, MatricesUniformBufferID); 
glBindBufferBase(GL_UNIFORM_BUFFER, 1, MatricesUniformBufferID);
GLsizeiptr TotalBufferSize = sizeof(glm::mat4) + sizeof(glm::mat4);
TotalBufferSize += sizeof(glm::mat3);
//uploading to the unbound array buffer
glBufferData(GL_ARRAY_BUFFER, TotalBufferSize, NULL, GL_DYNAMIC_DRAW); 
glBindBuffer(GL_UNIFORM_BUFFER, NULL);

所以你需要改变

glBufferData(GL_ARRAY_BUFFER, TotalBufferSize, NULL, GL_DYNAMIC_DRAW);

到

glBufferData(GL_UNIFORM_BUFFER, TotalBufferSize, NULL, GL_DYNAMIC_DRAW);

另外上传 NULL 在我的 OpenGL 驱动程序上不起作用(尽管它应该)，所以我不得不

std::array<unsigned char,sizeof(glm::mat4)*2+sizeof(glm::mat3)> buff;
glBufferData(GL_UNIFORM_BUFFER, TotalBufferSize, buff.data(), GL_DYNAMIC_DRAW);

至于您如何找到它:老派方法是在您的代码中使用仅在 Debug模式下才会出现的 glGetError 调用。更现代的方法是创建一个调试上下文并在回调上打印中断以找出错误的位置(然后你可以在该区域进行 glGetError 调用以获得确切的函数调用，如果你不到那时还不知道，因为现代 OpenGL 驱动程序是线程化的，回调可能会在一两次函数调用后触发。

关于c++ - OpenGL 简单立方体未出现，使用统一 block ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26584755/

文章推荐： jquery - onClick 循环遍历多组 DIV？

文章推荐： javascript - 使用 querySelector 通过 InnerHTML 选择元素

文章推荐： javascript - 更改div信息onclick

文章推荐： javascript - 需要帮助使用 CSS 调整图像网格大小

logic - 前向链接一阶逻辑(统一)
我正在为期末考试学习，但我无法理解这个 FC 算法: 我理解你标准化每条规则的部分。然后我认为下一行是说对于满足广义 Modus Ponens (p'_iTheta = p_iTheta) 的每个 t
unity3d - 统一，如何使摩擦与运动一起工作
我有一个 3d 世界，它有一个 simpel 平台和一个代表玩家的立方体。当我旋转平台时，立方体会滑动并按照您预期的方式执行，增加和减少物理 Material 中的摩擦力。我希望立方体在输入例如 f
unity3d - 加载我的场景时发生未知错误。统一
所以我的 Unity 项目有一个大问题。我昨天工作，我没有做备份今天，在我打开项目后，我的笔记本电脑因电池电量不足而关机。之后，当我进入项目时，我得到了这个:加载“Assets/MyScene.uni
haskell - 列表推导中的“统一”
好的，我正在尝试创建一个函数来确定元组列表是否是可传递的，即如果 (x,y) 和 (y,z) 在列表中，那么 (x,z) 也在列表中。例如，[(1,2), (2,3), (1,3)]是传递的。现在
c# - 移动窗口切换时如何保持时间引用？ (统一)
这个问题在这里已经有了答案: How to pass data between scenes in Unity (5 个回答) 9 个月前关闭。我有一个游戏，我有一个队列匹配系统。我想向玩家展示他
java - JDK目录未设置或无效(统一)？
我现在正在为我的游戏创建一个 keystore (统一)但是当我按下添加键按钮时，会弹出一个错误 Java Development Kit (JDK) directory is not set or
android - Cardboard的YouTube视频流(统一)
我想将YouTube流视频放入Cardboard(适用于Android和iOS)应用中。我知道这些插件可以执行类似的操作，例如“Easy Movie Texture”，但它们不支持YouTube流媒体
unity3d - 统一。关节角度限制是什么意思？
我需要限制 ConfigurableJoint 的目标旋转以避免关节变形或破坏。为了了解角度限制的工作原理，我做了一个实验。在场景中放置一个人形模型。为骨骼添加ConfigurableJoint
regex - 人工智能匹配，统一
尝试实现一种有限形式的匹配统一。尝试匹配两个公式匹配如果我们能找到替代出现在公式中的变量使得两者在句法上是等价。我需要写一个函数来判断一个对应于基本项的常数，例如 Brother(George)
c# - 用电子邮件发送日志文件？统一
我正在使用 Unity 和 C#我想在运行时将输出日志文件发送到我的电子邮件，我使用了来自 this question 的 ByteSheep 答案和来自 this question 的 Arkane
c# - 统一，加电碰撞问题
关闭。这个问题需要debugging details .它目前不接受答案。编辑问题以包含 desired behavior, a specific problem or error, and th
c# - 如何在单击游戏对象时创建菜单？ (统一)
我希望能够将鼠标悬停在游戏对象(代理)上并在右键或左键单击时创建一个类似于 Windows 右键单击菜单的 float 菜单。我试过结合使用 OnGUI() 和 OnMouseOver() 但我要
c# - 统一 - 在特定时间后改变场景
我正在为 oculus Gear VR 开发游戏(考虑内存管理)，我需要在特定时间(以秒为单位)后加载另一个屏幕 void Start () { StartCoroutine (loadSce
javascript - 统一/如何设置敌人生成的限制？
我设法生成了敌人，但它们一直在生成。如何设置限制，避免不断生成？我已经尝试添加 spawnLimit 和 spawnCounter 但无法让它工作。 var playerHealth = 100;
c# - 统一(对象名称与游戏对象)
我正在参加使用 Unity 进行游戏开发的在线类(class)，讲师有时会含糊不清。我的印象是使用游戏对象与使用游戏对象名称(在本例中为 MusicPlayer)相同，但是当我尝试将 MusicPla
c# - 统一;随机物体运动
关闭。这个问题需要更多focused .它目前不接受答案。想改进这个问题吗？更新问题，使其只关注一个问题 editing this post . 关闭 6 年前。 Improve this qu
java - 统一 - 无限的结果
为了好玩，我正在(用 Java)开发一个使用统一算法的应用程序。我选择了我的统一算法返回所有可能的统一。例如，如果我尝试解决添加(X，Y)=成功(成功(0)) 返回 {X = succ(succ(
c# - 统一。一定时间后的函数调用
如何让对象在一段时间后不可见(或只是删除)？使用 NGUI。我的示例(更改): public class scriptFlashingPressStart : MonoBehaviour {
c# - 找不到类型或命名空间名称 'NUnit' |统一
我有下一个错误: The type or namespace name 'NUnit' could not be found (are you missing a using directive or
android - 如何以编程方式将 autoSizeTextType 统一？
这是可以做到的但是属性 autoSizeTextType 只能用于 API LEVEL >= 26，并且 Android Studio 会显示有关该问题的烦人警告。为了摆脱这个问题，我想以编程方

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - OpenGL 简单立方体未出现，使用统一 block