Compute Shader write to texture

Question

I have implemented CPU code that copies a projected texture to a larger texture on a 3d object, 'decal baking' if you will, but now I need to implement it on the GPU. To do this I hope to use compute shader as its quite difficult to add an FBO in my current setup.

Example image from my current implementation

This question is more about how to use Compute shaders but for anyone interested, the idea is based on an answer I got from user jozxyqk, seen here: https://mcmap.net/q/1914093/-write-to-texture-glsl

The texture that is written-to is in my code called _texture, whilst the one projected is _textureProj

Simple compute shader

const char *csSrc[] = {
    "#version 440\n",
    "layout (binding = 0, rgba32f) uniform image2D destTex;\
     layout (local_size_x = 16, local_size_y = 16) in;\
     void main() {\
           ivec2 storePos = ivec2(gl_GlobalInvocationID.xy);\
           imageStore(destTex, storePos, vec4(0.0,0.0,1.0,1.0));\
    }"
};

As you see I currently only want to have the texture updated to some arbitrary (blue) color.

Update function

void updateTex(){ 
    glUseProgram(_computeShader);
    const GLint location = glGetUniformLocation(_computeShader, "destTex"); 
    if (location == -1){
        printf("Could not locate uniform location for texture in CS");
    }
    // bind texture
    glUniform1i(location, 0); 
    glBindImageTexture(0, *_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
    // ^second param returns the GLint id - that im sure of. 

    glDispatchCompute(_texture->width() / 16, _texture->height() / 16, 1); 
    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);

    glUseProgram(0);
    printOpenGLError(); // reports no errors.
}

Problem If i call the updateTex() outside of my main program object i see zero effect, whereas if I call it within its scope like so:

 glUseProgram(_id); // vert, frag shader pipe
  updateTex();
  // Pass uniforms to shader 
  // bind _textureProj & _texture (latter is the one im trying to update) 
 glUseProgram(0);

Then upon rendering I see this:

QUESTION: I realise that setting the update method within the main program object scope is not the proper way of doing it, however its the only way to get any visual results. It seems to me that what happens is that it pretty much eliminates the fragmentshader and draws to screenspace...

What can I do to get this working properly? (my main focus is to be able to write anything to the texture & update)

Please let me know if more code needs posting.

Karmen

I'm not sure what you mean by "main program object scope". What does _programObject->activate(); do? – Sass

Is your "main program scope" on a seperate thread? OpenGL will not function properly/at all when you makes calls between threads. – Canyon

@Sass - Oh, sorry, perhaps I used the wrong term there. What _programObject->activate() does essentially is that it calls glUseProgram(id) where id is GLint, I will edit my question. – Karmen

@newObjekt its not on a separate thread, i might have used the wrong terminology there, I meant within glUseProgram() – Karmen

Answer 1

I believe in this case an FBO would be easier and faster, and would recommend that instead. But the question itself is still quite valid.

I'm surprised to see a sphere, given you're writing blue to the entire texture (minus any edge bits if the texture size is not a multiple of 16). I guess this is from code elsewhere.

Anyway, it seems your main problem is being able to write to the texture from a compute shader outside the setup code for regular rendering. I suspect this is related to how you bind your destTex image. I'm not sure what your TexUnit and activate methods do, but to bind a GL texture to an image unit, do this:

int imageUnitIndex = 0; //something unique
int uniformLocation = glGetUniformLocation(...);
glUniform1i(uniformLocation, imageUnitIndex); //program must be active
glBindImageTexture(imageUnitIndex, textureHandle, ...);

see:

• https://www.opengl.org/sdk/docs/man/html/glBindImageTexture.xhtml
• https://www.opengl.org/wiki/Image_Load_Store#Images_in_the_context

Lastly, as you're using image2D so GL_SHADER_IMAGE_ACCESS_BARRIER_BIT is the barrier to use. GL_SHADER_STORAGE_BARRIER_BIT is for storage buffer objects.

Gifford

Thank you for a quick reply. I have actually tried doing it explicitly (edited my post to what your suggesting). I wasnt entirerly sure about the format but upon checking, its GL_RGB, which seems is not supported by the load/store method. So, as I get no glError with GL_RGBA32F im assuming its the way to go. Also, you see now im explicitly binding to 0 using the layout qualifier - still does not work. I suspect its either to do with the format (shouldt be) or theres a missin step in how the texture is loaded or something. – Karmen

Continuing: to mee it looks like Ive done a 'textbook' implementation so I will try again using FBO (and post questions to that in the other thread) but i'll keep this code, commented. Let me know if I should post any more code to this, right now Im a bit clueless as to why its not doing what its supposed to. Perhaps Im omitting cruicial code, let me know (and thank you!). – Karmen

Oh and another thing: the reason we see the "blue" sphere is just because Im plugging the updateTex() method within the glUseProgram() calls - ie - it looks like it removes the fragment shader. I know now the color is based on the projected vert shader vec4 position, which is why its blue - run time and it changes color based on angle of projector vs surface - completely wrong, but thats the only way I see anything to do with the compute shader... :( – Karmen