OpenGL, render to texture with floating point color without clipping value

Question

I am not really sure what the English name for what I am trying to do is, please tell me if you know.

In order to run some physically based lighting calculations. I need to write floating point data to a texture using one OpenGL shader, and read this data again in another OpenGL shader, but the data I want to store may be less than 0 or above 1.

To do this, I set up a render buffer to render to this texture as follows (This is C++):

//Set up the light map we will use for lighting calculation
glGenFramebuffers(1, &light_Framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, light_Framebuffer);
glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);//Needed for light blending (true additive)

glGenTextures(1, &light_texture);
glBindTexture(GL_TEXTURE_2D, light_texture);
//Initialize empty, and at the size of the internal screen
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_FLOAT, 0);

//No interpolation, I want pixelation
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

//Now the light framebuffer renders to the texture we will use to calculate dynamic lighting
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, light_texture, 0);
GLenum DrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, DrawBuffers);//Color attachment 0 as before

Notice that I use type GL_FLOAT and not GL_UNSIGNED_BYTE, according to this discussion Floating point type texture should not be clipped between 0 and 1.

Now, just to test that this is true, I simply set the color somewhere outside this range in the fragment shader which creates this texture:

#version 400 core    
void main()
{
    gl_FragColor =  vec4(2.0,-2.0,2.0,2.0);
}

After rendering to this texture, I send this texture to the program which should use it like any other texture:

glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, light_texture );//This is the texture I rendered too
glUniform1i(surf_lightTex_ID , 1);//This is the ID in the main display program

Again, just to check that this is working I have replaced the fragment shader with one which tests that the colors have been saved.

#version 400 core

uniform sampler2D lightSampler;

void main()
{
    color = vec4(0,0,0,1);
    if (texture(lightSampler,fragment_pos_uv).r>1.0)
        color.r=1;
    if (texture(lightSampler,fragment_pos_uv).g<0.0)
        color.g=1;
}

If everything worked, everything should turn yellow, but needless to say this only gives me a black screen. So I tried the following:

#version 400 core

uniform sampler2D lightSampler;

void main()
{
    color = vec4(0,0,0,1);
    if (texture(lightSampler,fragment_pos_uv).r==1.0)
        color.r=1;
    if (texture(lightSampler,fragment_pos_uv).g==0.0)
        color.g=1;
}

And I got

The parts which are green are in shadow in the testing scene, nevermind them; the main point is that all the channels of light_texture get clipped to between 0 and 1, which they should not do. I am not sure if the data is saved correctly and only clipped when I read it, or if the data is clipped to 0 to 1 when saving.

So, my question is, is there some way to read and write to an OpenGL texture, such that the data stored may be above 1 or below 0.

Also, No can not fix the problem by using 32 bit integer per channel and by applying a Sigmoid function before saving and its inverse after reading the data, that would break alpha blending.

Answer 1

The type and format arguments glTexImage2D only specify the format of the source image data, but do not affect the internal format of the texture. You must use a specific internal format. e.g.: GL_RGBA32F:

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);