In OpenGL ES 2.0, How to read neighboring texels from a Sampler

glslopengl-esopengl-es-2.0

I am passing a texture with NxM size as a sampler in the GLSL fragment shader (OpenGL ES 2.0). What is the right way to read the texel data from the neighboring texel ? I do not have a "varying" texture coordinate in the fragment shader. I can only use fragment coordinate to read the texture information.

following is my shader, I am not sure if its actually reading the data:

precision mediump float;

uniform sampler2D Sampler;

#define OFFSET 1.0

void main()
{

    vec2 T = gl_FragCoord.xy;

    //Find neighboring velocities:
    vec2 N = texture2D(Sampler,vec2(T.x,T.y+OFFSET)).xy;
    vec2 S = texture2D(Sampler,vec2(T.x,T.y-OFFSET)).xy;
    vec2 E = texture2D(Sampler,vec2(T.x+OFFSET,T.y)).xy; 
    vec2 W = texture2D(Sampler,vec2(T.x-OFFSET,T.y)).xy; 
}

Is the OFFSET value should be 1.0 OR something else for NxM size texture ?

Best Answer

Nem is right in his answer that the texture coordinate should be in [0,1]. But keep in mind, that the values of gl_FragCoord are in [0,N]x[0,M] (assuming your viewport is NxM, too). So you are correct in adding an offset of 1 to the fragment coordinate, but this sum has then to be divided by the screen size (which is probably the same as the texture size):

precision mediump float;

uniform sampler2D Sampler;
uniform vec2 invScreenSize;

void main()
{

    vec2 T = gl_FragCoord.xy;

    //Find neighboring velocities:
    vec2 N = texture2D(Sampler,vec2(T.x,T.y+1.0)*invScreenSize).xy;
    vec2 S = texture2D(Sampler,vec2(T.x,T.y-1.0)*invScreenSize).xy;
    vec2 E = texture2D(Sampler,vec2(T.x+1.0,T.y)*invScreenSize).xy; 
    vec2 W = texture2D(Sampler,vec2(T.x-1.0,T.y)*invScreenSize).xy; 
}

where invScreenSize is the reciprocal screen size (1/N, 1/M), to prevent division in the shader.

Related Solutions

Iphone – Passing a variable to an OpenGL GLSL shader

One option is to pass information via uniform variables.

After

glUseProgram(myShaderProgram);

you can use

GLint myUniformLocation = glGetUniformLocation(myShaderProgram, "myUniform");

and for example

glUniform1f(myUniformLocation, /* some floating point value here */);

In your vertex or fragment shader, you need to add the following declaration:

uniform float myUniform;

That's it, in your shader you can now access (read-only) the value you passed earlier on via glUniform1f.

Of course uniform variables can be any valid GLSL type including complex types such as arrays, structures or matrices. OpenGL provides a glUniform function with the usual suffixes, appropriate for each type. For example, to assign to a variable of type vec3, one would use glUniform3f or glUniform3fv.

Note: the value can't be modified during execution of the shader, i.e. in a glBegin/glEnd block. It is read-only and the same for every fragment/vertex processed.

There are also several tutorials using uniforms, you can find them by googling "glsl uniform variable".

I hope that helps.

Textured points in OpenGL ES 2.0

You select your texture as active and bind it - like normally. But you must pass your texture unit as uniform to the shader program. So you can use the gl_PointCoord as texture coordinates in your fragment shader.

glUniform1i(MY_TEXTURE_UNIFORM_LOCATION, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, yourTextureId);
glEnable(GL_TEXTURE_2D);
glDrawArrays(GL_POINTS, 0, pointCount);
glDisable(GL_TEXTURE_2D);

And your fragment shader should look like:

uniform sampler2D texture;
void main ( )
{
    gl_FragColor = texture2D(texture, gl_PointCoord);
}

Best Answer

Related Solutions

Iphone – Passing a variable to an OpenGL GLSL shader

Textured points in OpenGL ES 2.0

Related Topic