Opengl 使用GLSL计算着色器渲染纹理时遇到问题

我看过其他人对它的实施情况，但我仍然不确定我做错了什么。我的图形驱动程序是最新的，没有收到任何错误消息

我尝试使用GLSL计算着色器写入纹理，然后将其渲染到屏幕大小的四元体上

以下是my 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;
    }

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;
}

朱莉娅·康普：

#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块获取颜色，但如果我将其设置为

storePos.x>100&&storePos.x<513

我将获得两种颜色的混合

任何帮助都将不胜感激

编辑： 我得到的图像：

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

这就是为什么我认为它在某种程度上混合了颜色。（注意，黄色也相当暗淡，这表明颜色是平均的，而不是加在一起的）

编辑：我试着将放大滤镜设置为最近的GL_，这会在整个屏幕上产生明亮的红色纹理。（两种颜色之间没有混合）

---

编辑：“OpenGL计算着色器-奇怪的结果”一文没有解决我的问题。askers的问题是他用于矩阵计算的特定库，而我的答案中甚至没有使用一个矩阵。我也尝试过该帖子上的其他建议，但没有一个有效。

到

glvertexattributepointer

的偏移量是以字节为单位的。你传递一个

（void*）（3）

对于应该是什么

（void*）（3*sizeof（float））

：

---

glvertexattributepointer（1,2，GL_FLOAT，GL_FALSE，5*sizeof（FLOAT），（void*）（3*sizeof（FLOAT）））；//你能贴一张你得到的图片吗？当然可以，添加了图片。我猜这与uv坐标不正确有关set@Elihah种子Arita你知道我如何修正UV坐标吗？我的理解是UV坐标应该始终在[0,1]中范围，坐标似乎与顶点中使用的坐标相匹配。@TrevorGalivan：“askers的问题与他用于矩阵计算的特定库有关，我甚至没有在我的答案中使用一个矩阵。”不，这个问题是（部分）使用了哪个内存屏障。您也犯了同样的错误。这解决了问题。非常感谢！我应该在参数以字节为单位之前意识到
stride
参数。
#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));
    }
}

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