使用GLSL计算着色器渲染纹理时遇到麻烦

Question

我已经查看了其他人的实现，但仍然不确定自己在做什么错。我的图形驱动程序是最新的，并且没有收到错误消息。

[我正在尝试使用GLSL计算着色器来写入纹理，然后将其渲染到屏幕尺寸的四边形上。

这是我的main.cpp的代码：

unsigned int hRes = 512;
unsigned int vRes = 512;

int main(void) {

    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow(hRes, vRes, "Learn OpenGL", NULL, NULL);

    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    glViewport(0, 0, hRes, vRes);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    //
    float vertices[] = {
         // positions     // Tex coords
         1.f,  1.f, 0.0f,  1.f,  1.f, // top right
         1.f, -1.f, 0.0f,  1.f,  0.f,  // bottom right
        -1.f, -1.f, 0.0f,  0.f,  0.f,  // bottom left
        -1.f,  1.f, 0.0f,  0.f,  1.f,   // top left 
    };
    unsigned int indices[] = {  
        0, 1, 3,   // first triangle
        1, 2, 3    // second triangle
    };

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

    unsigned int VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(0));
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3));
    glEnableVertexAttribArray(1);


    unsigned int EBO;
    glGenBuffers(1, &EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);


    unsigned int texture;
    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);
    float borderColor[] = { 1.0f, 1.0f, 0.0f, 1.0f };
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, hRes, vRes, 0, GL_RGBA, GL_FLOAT, NULL);
    glBindImageTexture(0, texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);

    // Vertex and fragment shaders are pretty much empty, and just pass through vertex/texture coord data
    Shader vertex("doNothing.vert", GL_VERTEX_SHADER);
    Shader fragment("doNothing.frag", GL_FRAGMENT_SHADER);
    ShaderProgram renderProg;
    renderProg.attach(vertex);
    renderProg.attach(fragment);
    renderProg.link();

    Shader computeShader("julia.comp", GL_COMPUTE_SHADER);
    ShaderProgram computeProg;
    computeProg.attach(computeShader);
    computeProg.link();

    while (!glfwWindowShouldClose(window))
    {
        // Input (currently does nothing)
        processInput(window);

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        computeProg.use();
        glDispatchCompute(hRes / 16, vRes / 16, 1); // For local work group size 16. Ensures entire texture is written to

        glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);

        renderProg.use();
        glBindTexture(GL_TEXTURE_2D, texture);
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);


        // End drawing current frame
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);
    glfwTerminate();
    return 0;
    }

ShaderProgram和Shader只是包装OpenGL对象ID的帮助程序类。

着色器代码：doNothing.frag：

#version 460 core
out vec4 FragColor;

in vec2 TexCoord;
uniform sampler2D ourTexture;

void main()
{
    FragColor = texture(ourTexture, TexCoord);
}

doNothing.vert：

#version 460 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;

out vec2 TexCoord;

void main()
{
    gl_Position = vec4(aPos, 1.0);
    TexCoord = aTexCoord;
}

julia.comp：

#version 460
layout (binding = 0, rgba32f) uniform writeonly image2D destTex;
layout (local_size_x = 16, local_size_y = 16) in;
void main() {
    ivec2 storePos = ivec2(gl_GlobalInvocationID.xy);

    if(storePos.x > 100){
        imageStore(destTex, storePos, vec4(0., 0., 1.0, 1.0));
    }else{
        imageStore(destTex, storePos, vec4(1., 0., 0.0, 1.0));
    }
}

我希望这段代码输出的图像中，一部分是红色的，而另一部分是蓝色的。代替发生的是它输出单色图像，其中整个屏幕都是红色和蓝色的混合。

我已经在julia.comp着色器中处理了各种条件，并且似乎如果我设置条件以使每个角的颜色不同，我会得到各种角颜色的混合（如果设置了条件，则为EG到storePos.x > 100 && storePos.x < 511时，我只能从else块中获得颜色，但是如果将其设置为storePos.x > 100 && storePos.x < 513，则可以得到两种颜色的混合。

任何帮助将不胜感激。

编辑：我得到的图像：

如果我在“ if”代码块中将vec4（0。，0.，1.，1.）替换为vec4（0。，1.，0.，1.），就会发生这种情况：

这就是为什么我认为它以某种方式融合了颜色。 （请注意，黄色也相当暗淡，这表明颜色已经取平均值，没有加在一起）

编辑：我尝试将放大滤镜设置为GL_NEAREST，这会导致整个屏幕上出现鲜红色的纹理。 （两种颜色之间不混合）

编辑：文章“ OpenGL计算着色器-奇怪的结果”不能解决我的问题。提问者的问题是他使用特定的库进行矩阵计算，而我的答案中甚至没有使用单个矩阵。我还尝试了该职位上的其他建议，但没有一个起作用。

Answer 1

glVertexAttribPointer的偏移量以字节为单位。您将(void*)(3)传递为(void*)(3*sizeof(float))：

glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float))); // <--- here