【问题标题】：glUniformMatrix4fv causing GL_INVALID_OPERATIONglUniformMatrix4fv 导致 GL_INVALID_OPERATION
【发布时间】：2015-05-30 15:08:45
【问题描述】：

当我在下面的代码中调用 glUniformMatrix4fv 或 glUniform4fv 时，它每次都会引发 GL_INVALID_OPERATION，我尝试更改传递矩阵数据的方式，传递 id 的计数，我检查了模型 id 和着色器程序但可以不知道为什么会这样。

这是着色器：

版本 330

uniform vec4 projection; /* view port / perspective */
uniform vec4 model; /* object */
uniform vec4 view; /*camera */
in vec3 position;

void main() {
    gl_Position = projection * view * model * vec4(position, 1.0);
}

这是我的代码：

#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
#include <fstream>
#include <stdlib.h>

GLuint getShader(const char* shaderName, GLenum shaderType) {
    /* Read file */
    std::ifstream shaderFile;
    shaderFile.open(shaderName, std::ios_base::in);

    if(!shaderFile) {
        std::cout <<  shaderName << " not found" << std::endl;
        return 0;
    }

    std::string line;
    std::string shaderData;
    while(std::getline(shaderFile, line)) {
        shaderData += line + "\n";
    }

    shaderFile.close();

    /* Create shader */
    GLuint shader = glCreateShader(shaderType);

    if(shader == 0) {
        std::cout << "Failed to create shader for " << shaderName << std::endl;
        return 0;
    }

    const char *shaderStr = shaderData.c_str();

    glShaderSource(shader, 1, &shaderStr, nullptr);
    glCompileShader(shader);

    /* Check compile status */
    GLint status;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if(status != GL_TRUE) {
        GLint logLength;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);

        GLchar* infoLog = new GLchar[logLength + 1];
        glGetShaderInfoLog(shader, logLength, nullptr, infoLog);

        std::cout << shaderName << " failed to compile: " << infoLog << std::endl;
        return 0;
    }

    return shader;
}

int end(const char* message) {
    glfwTerminate();

    if(message != nullptr) {
        std::cout << message << std::endl;
        system("PAUSE");
    }
    return 1;
}

int main() {
    /* Initial checks */
    if (!glfwInit()) {
        return end("Failed to startup GLFW");
    }

    /* Create the window */
    GLFWwindow *window = glfwCreateWindow(500, 500, "3D world prototyping", nullptr, nullptr);

    if (!window) {
        return end("Failed to create window.");
    }

    glfwMakeContextCurrent(window); //make the window active

    /* Startup GLEW */
    glewExperimental = GL_TRUE;
    if (glewInit() != GLEW_OK) {
        return end("Failed to startup GLEW");
    }

    /* Start OpenGL constants */
    glEnable(GL_DEPTH_TEST);
    glViewport(0, 0, 500, 500);

    /* Support for multiple shaders without the need to switch attributes */
    GLuint vertexArray;
    glGenVertexArrays(1, &vertexArray);
    glBindVertexArray(vertexArray);

    /* Create buffers */
    GLuint vertexBuffer;
    glGenBuffers(1, &vertexBuffer);

    /* Shape vectors */
    GLfloat verticies[] = { //X, Y, Z
            -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,

            -1.0f, -1.0f, -0.5f,
            1.0f, -1.0f, -0.5f,
            1.0f, 1.0f, -0.5f,
            1.0f, 1.0f, -0.5f,
            -1.0f, 1.0f, -0.5f,
            -1.0f, -1.0f, -0.5f
    };
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verticies), verticies, GL_STATIC_DRAW);

    /* Load in the shaders */
    GLuint fragmentShader = getShader("fragmentShader.glsl", GL_FRAGMENT_SHADER);
    GLuint vertexShader = getShader("vertexShader.glsl", GL_VERTEX_SHADER);

    if (fragmentShader == 0 || vertexShader == 0) {
        return end("Failed to load shaders");
    }

    /* Setup the shaders */
    /* Create the shader program and use it */
    GLuint shaderProgram = glCreateProgram();

    if (shaderProgram == 0) {
        return end("Failed to create shader program");
    }

    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glBindFragDataLocation(shaderProgram, 0, "outColor"); //tell opengl about the out color variable
    glLinkProgram(shaderProgram);

    if(glIsProgram(shaderProgram) != GL_TRUE) {
        return end("Failed to create shader program");
    }

    /* Positioning */
    //FOV, Screen ratio, display range short, display range long
    glm::mat4 projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.0f);
    glm::mat4 view = glm::lookAt(
        glm::vec3(4.0f, 3.0f, 3.0f), // Camera
        glm::vec3(0.0f, 0.0f, 0.0f), // Where the camera looks up
        glm::vec3(0.0f, 1.0f, 0.0f)  // Pitch of the head
    );
    glm::mat4 model = glm::mat4(1.0f);

    /* Rendering and logic */
    while (!glfwWindowShouldClose(window)) {
        /* Shutdown logic */
        if (glfwGetKey(window, GLFW_KEY_ESCAPE)) {
            break;
        }

        /* Clear */
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);

        /* Logic */
        glUseProgram(shaderProgram);

        GLint projectionId = glGetUniformLocation(shaderProgram, "projection");
        GLint viewId = glGetUniformLocation(shaderProgram, "view");
        GLint modelId = glGetUniformLocation(shaderProgram, "model");

GLenum error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Uniform error " << error << ": " << glewGetErrorString(error) << std::endl;
            return end("");
        }
        else if(projectionId == -1) {
            return end("Projection ID failed to load");
        }
        else if(viewId == -1) {
            return end("View ID failed to load");
        }
        else if(modelId == -1) {
            return end("Model ID failed to load");
        }

        glUniformMatrix4fv(viewId, 3, GL_FALSE, glm::value_ptr(view));

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "View uniform matrix error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glUniformMatrix4fv(projectionId, 3, GL_FALSE, glm::value_ptr(projection));

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Projection matrix error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glUniformMatrix4fv(modelId, 3, GL_FALSE, glm::value_ptr(model));

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Model uniform matrix error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        /* Tell opengl about all the attributes */
        GLint positionAttribute = glGetAttribLocation(shaderProgram, "position");

        if(positionAttribute == -1) {
            std::cout << "Error: position attribute failed to load" << std::endl;
            end("");
        }
        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Position attribute error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glEnableVertexAttribArray(positionAttribute);

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Vertex enable error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Buffer bind error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, GL_FALSE, 0, 0); //because not just XYZ need to tell opengl the size of the stride

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Vertex attrib pointer error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        /* Draw */
        glDrawArrays(GL_TRIANGLES, 0, 36);

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "gl draw arrays " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glDisableVertexAttribArray(positionAttribute);

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "gl disable attrib error " << error << ": " << glewGetErrorString(error) << std::endl;
        }

        glfwSwapBuffers(window);
        glfwPollEvents();

        error = glGetError();
        if(error != GL_NO_ERROR) {
            std::cout << "Error " << error << ": " << glewGetErrorString(error) << std::endl;
        }
    }

    glfwDestroyWindow(window);
    glDeleteProgram(shaderProgram);
    glDeleteShader(fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteBuffers(1, &vertexBuffer);
    glDeleteVertexArrays(1, &vertexArray);
    return end(nullptr);
}

【问题讨论】：

当你的着色器不使用一些统一时，它可能会被优化出来并从着色器代码中完全删除。在这种情况下，glGetUniformLocation 将返回 -1。检查 viewId 是否有任何有意义的值。那是你忘记的步骤。
现在刚刚添加（并更新了邮政编码），如果被解雇，其他任何一个都没有，它们都有实际值
这不会帮助您解决问题，但您应该只在链接程序后查询那些统一的位置，而不是每个应用程序的主循环一次。除非您重新链接程序，否则它们不会更改位置，并且在加载时验证它们比循环的每次迭代要容易得多。
话虽如此，您能否展示相关着色器的主体？我的印象是 projectionId 没有声明为 mat4 [3]，这会使特定的 API 调用无效。
好的，我将它们移到那里，我最初确实有它们，但是当我浏览例如人们将它们放入循环中的代码时，我认为它们被 useProgram 或其他东西重置了。编辑：当然我现在会添加它

标签： c++ opengl

【解决方案1】：

对于有问题的特定制服，您使用了错误的 API 调用来设置它们。

这些是向量，而不是矩阵。您将使用glUniform4fv (...) 而不是glUniformMatrix4fv (...)。后一个函数假定您正在设置 1 个或多个 4x4 矩阵制服（您传递的参数告诉它 projection 应该是 3 个 mat4s 的数组）。

我相信在您的情况下，适当的函数调用应该是这样的：

glUniform4fv (modelId, 1, glm::value_ptr(model)); // Fill 1 4D vector, not an array of vectors

【讨论】：

这是有道理的，当我猜它是一个 4D 向量时，我只是将 glm mat4 视为 4D 矩阵。感谢您的帮助，我不再收到任何错误，但我的立方体仍然没有绘制，您可以跟进stackoverflow.com/questions/30540117/…
@user1763295：对不起，我有点回答了你的问题，然后昨天不得不运行。我认为您的问题是那些声明为vec4 的变量实际上应该是mat4。当他们被宣布为vec4 时，我的回答有效，但这可能不是初衷。

【解决方案2】：

当您调用的 setter 函数与您尝试设置的制服的数据类型不匹配时，设置制服将导致 GL_INVALID_OPERATION 错误。

既然你将你的制服声明为向量：

uniform vec4 projection; /* view port / perspective */
uniform vec4 model; /* object */
uniform vec4 view; /*camera */

您不能使用 matrix 设置器。您应该将您的制服更改为 mat4 以使您的代码正常工作。

附带说明：如果您尝试设置位置为 -1 的制服（意味着制服不存在或已被优化），它不会产生错误。这是明确允许的，可能是为了允许着色器可能只使用制服子集的通用框架。

【讨论】：