在Vertex Shader中声明均匀后，OpenGL无法渲染

Question

我已经和Modern OpenGL（4.1）一起玩了一遍，直到我进入阴影领域，一切都很好。

但在我用阴影渲染之前，我遇到了顶点着色器的一些问题。

程序非常简单，它只是读取OBJ文件以及网格的纹理。我将这些东西放在各自的缓冲区中然后绘制它。起初它完全绘制了所有内容，但后来我在顶点着色器和BAM中添加了2个uniform变量！什么都没画。有趣的是：一旦我评论一件额外的制服，一切都会再次呈现。

我真的不明白这里发生了什么，我以为我是在推断制服的任何限制，但它只是3 mat4制服，从我用Google搜索，我至少有1024 [{{ 3}}]。

无论如何，我没有想法，谷歌查询，所以我来到你的帮助。 在此先感谢!!

啊，我正在使用MacOSX El Captain和一些环境信息（来自glGetString）： 版本：4.1 ATI-1.40.16 渲染器：AMD Radeon HD 6750M OpenGL引擎

一些不包含的代码只是上下文创建和着色器编译。 请注意，如果我删除uniform mat4 mM;，它就能完美运行。否则，它会继续打印“位置 - > -1”（说它找不到任何统一）。 我真的不知道发生了什么。

P.S。：也请不要介意可怕的代码，仍然试图弄清楚一些代码仍然不好。

vertexShader.gs：

#version 410
layout(location = 0) in vec3 vPosition;
layout(location = 1) in vec2 vTex;

out vec2 texCoord;

uniform mat4 mM;
uniform mat4 mV;
uniform mat4 mvp;

void main () {
    texCoord = vTex;

    gl_Position = mvp * vec4(vPosition, 1.0f);
}

Main.cpp的

#include <iostream>
#include <string>
#include <vector>

#include <OpenGl/gl.h>
//#define GLFW_INCLUDE_GLCOREARB
#include <GLFW/glfw3.h>

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

#include "picg.h"
#include "shader.h"
#include "tiny_obj_loader.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

void matrices(GLfloat xAngle, GLfloat yAngle);

glm::mat4 projection, view, model, rotations;
glm::mat4 mvp;
glm::vec3 light;

GLuint vao, vbo, ibo, tbo;
GLuint texture;
GLuint shaderProgram;

const GLfloat angle = 1.0f;

GLfloat cYAngle;
GLfloat cXAngle;
GLfloat scale = 1.0f;

GLfloat points[] = {
    -0.7f, +0.7f, +0.7f,
    -0.7f, -0.7f, +0.7f,
    +0.7f, -0.7f, +0.7f,
    +0.7f, +0.7f, +0.7f
};

GLuint indices[] = {
    0, 1, 2, 3, 0, 2
};

int main() {
    GLFWwindow * window = create_context("Fish club", 600, 600);
    initGL();

    GLubyte vertexShader = shaderFromFile("vertexShader.gs", GL_VERTEX_SHADER);
    GLubyte fragmentShader = shaderFromFile("fragmentShader.gs", GL_FRAGMENT_SHADER);

    projection = glm::perspective(glm::radians(+45.f), 1024.f / 768.f, 0.1f, 600.0f);

    view = glm::lookAt(
            glm::vec3(+0.0f,+0.0f,+5.0f),
            glm::vec3(+0.0f,+0.0f,+0.0f),
            glm::vec3(+0.0f,+1.0f,+0.0f)
    );

    model = glm::mat4(1.0f);
    model = glm::scale(model, glm::vec3(90.0f));
    mvp = projection * view * model;

    light = glm::vec3(0.0f, 1.0f, 1.0f);

    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;

    std::string err; 
    if (!tinyobj::LoadObj(shapes, materials, err, "res/GOLDFISH.obj")) {
        throw std::runtime_error(std::string("Error loading OBJ file:\n") + err);
    }

    std::cout << "Shapes: " << shapes.size() << std::endl
              << "Materials: " << materials.size() << std::endl
              << "Positions: " << shapes[0].mesh.positions.size() << std::endl
              << "Normals: " << shapes[0].mesh.normals.size() << std::endl
              << "TexCoords: " << shapes[0].mesh.texcoords.size() << std::endl;

    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    int width, height, numComponents;
    unsigned char * imageData = stbi_load("res/GOLDFISH.bmp",
                                    &width, &height, &numComponents, 4);

    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                imageData);
    glBindTexture(GL_TEXTURE_2D, NULL);

    stbi_image_free(imageData);

    GLsizei vertex_buffer_size = 0;
    for (int i = 0 ; i < shapes.size(); ++i) {
        vertex_buffer_size += sizeof(float) * shapes[i].mesh.positions.size();
    }
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBufferData(GL_ARRAY_BUFFER, vertex_buffer_size, NULL, GL_STATIC_DRAW);
        for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) {
            glBufferSubData(GL_ARRAY_BUFFER, offset, 
                    sizeof(float) * shapes[i].mesh.positions.size(), 
                    &shapes[i].mesh.positions[0]);

            offset += sizeof(float) * shapes[i].mesh.positions.size();
        }
    glBindBuffer(GL_ARRAY_BUFFER, NULL);

    GLsizei index_buffer_size = 0;
    GLsizei index_size = 0;
    for (int i = 0 ; i < shapes.size() ; ++i) {
        index_buffer_size += sizeof(float) * shapes[i].mesh.indices.size();
        index_size += shapes[i].mesh.indices.size();
    }
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_buffer_size, NULL, GL_STATIC_DRAW);
        for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) {
            glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset,
                    sizeof(unsigned int) * shapes[i].mesh.indices.size(),
                    &shapes[i].mesh.indices[0]);

            offset += sizeof(unsigned int) * shapes[i].mesh.indices.size();
        }
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);

    GLsizei texcoord_buffer_size = 0;
    for (int i = 0 ; i < shapes.size() ; ++i) {
        texcoord_buffer_size += sizeof(float) * shapes[i].mesh.texcoords.size();
    }
    glGenBuffers(1, &tbo);
    glBindBuffer(GL_ARRAY_BUFFER, tbo);
        glBufferData(GL_ARRAY_BUFFER, texcoord_buffer_size, NULL, GL_STATIC_DRAW);

        for (int i = 0, offset = 0 ; i < shapes.size() ; ++i) {
            glBufferSubData(GL_ARRAY_BUFFER, offset,
                    sizeof(float) * shapes[i].mesh.texcoords.size(),
                    &shapes[i].mesh.texcoords[0]);
            offset += sizeof(float) * shapes[i].mesh.texcoords.size();
        }
    glBindBuffer(GL_ARRAY_BUFFER, NULL);

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
            glEnableVertexAttribArray(0);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
        glBindBuffer(GL_ARRAY_BUFFER, tbo);
            glEnableVertexAttribArray(1);
            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    glBindVertexArray(NULL);

    glBindBuffer(GL_ARRAY_BUFFER, NULL);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);

    while (!glfwWindowShouldClose(window)) {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        cYAngle += 0.1f;

        matrices(cXAngle, cYAngle);

        glUseProgram(shaderProgram);
            std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mV") << std::endl;
            std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mM") << std::endl;
            std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mvp") << std::endl;
            glUniformMatrix4fv(
                    glGetUniformLocation(shaderProgram, "mvp"), 
                    1, GL_FALSE, &mvp[0][0]);

            glUniformMatrix4fv(
                    glGetUniformLocation(shaderProgram, "mV"), 
                    1, GL_FALSE, &view[0][0]);
            glUniformMatrix4fv(
                    glGetUniformLocation(shaderProgram, "mM"), 
                    1, GL_FALSE, &model[0][0]);

            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, texture);
            glUniform1i(glGetUniformLocation(shaderProgram, "textureSampler"), 0);

            glBindVertexArray(vao);
                glDrawElements(GL_TRIANGLES, index_buffer_size, GL_UNSIGNED_INT, NULL);
            glBindVertexArray(NULL);
        glUseProgram(NULL);

        glfwPollEvents();
        glfwSwapBuffers(window);
    }

    glfwTerminate();

    return 0;
}

void matrices(GLfloat xAngle, GLfloat yAngle) {
    model = glm::mat4(1.0f);
    model = glm::rotate(model, glm::radians(xAngle), glm::vec3(+1.0f, +0.0f, +0.0f));
    model = glm::rotate(model, glm::radians(yAngle), glm::vec3(+0.0f, +1.0f, +0.0f));
    model = glm::scale(model, glm::vec3(40.0f));

    mvp = projection * view * model;
}

编辑：

根据建议，我尝试了以下顶点着色器：

#version 410
layout(location = 0) in vec3 vPosition;
layout(location = 1) in vec2 vTex;

out vec2 texCoord;

uniform mat4 mM;
uniform mat4 mV;
uniform mat4 mP;

void main () {
    texCoord = vTex;

    gl_Position = mP * mV * mM * vec4(vPosition, 1.0f);
}

并更改了以下行

glUseProgram(shaderProgram);
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mP") << std::endl;
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mV") << std::endl;
    std::cout << "Location -> " << glGetUniformLocation(shaderProgram, "mM") << std::endl;

    glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mP"), 
        1, GL_FALSE, &projection[0][0]);
    glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mV"), 
        1, GL_FALSE, &view[0][0]);
    glUniformMatrix4fv(
        glGetUniformLocation(shaderProgram, "mM"), 
        1, GL_FALSE, &model[0][0]);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
    glUniform1i(glGetUniformLocation(shaderProgram, "textureSampler"), 0);
    glBindVertexArray(vao);
        glDrawElements(GL_TRIANGLES, index_buffer_size, GL_UNSIGNED_INT, NULL);
    glBindVertexArray(NULL);
glUseProgram(NULL);

然而，我什么都看不见，它只为每件制服返回“位置 - ＆gt; -1”。

Answer 1

您的顶点着色器代码中未使用

mM和mV。我相信它会在编译期间被删除，所以当您尝试使用glGetUniformLocation()获取其位置时，此信息不可用。尝试在着色器代码中使用mM和mV执行某些操作。