opengl - 使用 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 着色器内部的条件，似乎如果我设置条件以使每个角的颜色不同，我会得到角颜色的混合(例如，如果我设置将条件设置为 storePos.x > 100 && storePos.x < 511 我只能从 else block 中获得颜色，但如果将其设置为 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