使用 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 object 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));
    }
}

我希望此代碼為 output 圖像，其中一部分為紅色，另一部分為藍色。 相反，它會輸出一個單色圖像，其中整個屏幕是紅色和藍色的混合色。

我已經玩過 julia.comp 着色器內部的條件，似乎如果我設置條件使得每個角落的顏色都不同，我會得到角落顏色的混合（例如，如果我將條件設置為storePos.x > 100 && storePos.x < 511我只從 else 塊中獲得顏色，但如果我將其設置為storePos.x > 100 && storePos.x < 513我會得到兩種顏色的混合。

任何幫助，將不勝感激。

編輯：我得到的圖像：

如果我在“if”代碼塊中用 vec4(0., 1., 0., 1.) 替換 vec4(0., 0., 1., 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