Determining world position of the current fragment in a shader

[Blasphemer]

I am trying to make a lighting fragment shader. For that, I need to know the world position of the fragment in order to determine its distance to the light source (in world units). Should I do it by setting up a varying world coordinates variable in a vertex shader? If so, can SFML provide the model matrix needed to compute the vertex world position like this?:

vec2 world_coords = gl_Vertex * gl_ModelMatrix

Or should I compute the vertex world positions in SFML - getting the entity transform, applying it to local vertex coords then passing the results to the vertex shader?

Is this even the correct way to make a per-pixel lighting shader with SFML that would not change output with view/screen transformations?

[TheNess]

are you talking 2d or 3d?

I implemented a 2d lighting shader with normal maps and I sent the light position to the shader already converted to screen coords. I even asked this somewhat similar question:
http://en.sfml-dev.org/forums/index.php?topic=17352.0

so if you are talking 2d I can give you more info.

[Blasphemer]

are you talking 2d or 3d?

I implemented a 2d lighting shader with normal maps and I sent the light position to the shader already converted to screen coords. I even asked this somewhat similar question:
http://en.sfml-dev.org/forums/index.php?topic=17352.0

so if you are talking 2d I can give you more info.

Yes I am talking about 2D. I have already implemented the shader with the approach outlined in the OP. The code is here:

uniform sampler2D texture;

uniform vec2 light_position;
uniform vec4 light_color;
uniform float light_intensity;

uniform vec2 topleft;
uniform vec2 topright;
uniform vec2 bottomright;
uniform vec2 bottomleft;

vec2 resize_vect(vec2 vect, float lenght)
{
        float vect_lenght = sqrt(vect.x * vect.x + vect.y * vect.y); //get vector's lenght

        vect.x = vect.x / vect_lenght; //normalize vector
        vect.y = vect.y / vect_lenght;

        vect.x = vect.x * lenght; //multiply it by lenght
        vect.y = vect.y * lenght;

        return vect;
}

void main()
{
       
       
        vec2 fragment_position_x = topleft + resize_vect(topright - topleft, gl_TexCoord[0].x*3 * distance(topleft, topright));
        vec2 fragment_position_y = topleft + resize_vect(bottomleft - topleft, gl_TexCoord[0].y * distance(topleft, bottomleft));
        vec2 fragment_position = fragment_position_x + (fragment_position_y - topleft);
       
        vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);
       
        float intensity = (light_intensity/5) / clamp(distance(fragment_position, light_position), 0.001, 4000000.0);
       
        vec4 light = vec4(pixel.r*light_color.r*intensity, pixel.g*light_color.g*intensity, pixel.b*light_color.b*intensity, pixel.a);

        gl_FragColor = light;

(I have to multiply gl_TexCoord[0].x by 3 because I am also storing glow map and environment map in the same texture so the end of the first texture is at x = 1/3)

[TheNess]

to be honest I didn't fully understand what you are doing in the shader with the fragment_position calculation (maybe its because of the time , but if its 2d, why not calculating the distance in screen position? i.e. using the gl_FragCoord varying you already have built-in. or are you doing anything special in the vertex shader?

read more here: https://www.opengl.org/sdk/docs/man/html/gl_FragCoord.xhtml

also two tips about your code:

instead of this:

float vect_lenght = sqrt(vect.x * vect.x + vect.y * vect.y); //get vector's lenght

    vect.x = vect.x / vect_lenght; //normalize vector
    vect.y = vect.y / vect_lenght;
 

you can use normalize() to normal the vector and length() to get vector length (if you need it).

and instead of this:

vec4 light = vec4(pixel.r*light_color.r*intensity, pixel.g*light_color.g*intensity, pixel.b*light_color.b*intensity, pixel.a);
 

you can do something like this:

vec4 light = pixel;
light.rgb *= light_color.rgb * intensity;
 

I don't know if it helps but this is how I wrote my normal maps shader (rgb is normals, a is depth):

(click to show/hide)

////////////////////////////////////////////////
// UNIFORMS
////////////////////////////////////////////////

// the main texture (diffuse color)
uniform sampler2D texture;

// the normal map texture
uniform sampler2D normal_map;

// material specular
uniform float specular = 1.0f;

// ambient light
uniform vec3 light_ambient_color = vec3(0,0,0);

// factor to multiply light distance so that no matter what the screen size is lights will be at the same size
uniform float lights_size_factor = 1.0f;

// create a light uniform with unique index
uniform vec3 light_0_position = vec3(0,0,0);
uniform vec4 light_0_color = vec4(0,0,0,0);
uniform float light_0_glow = 1.0f;
uniform vec3 light_1_position = vec3(0,0,0);
uniform vec4 light_1_color = vec4(0,0,0,0);
uniform float light_1_glow = 1.0f;
uniform vec3 light_2_position = vec3(0,0,0);
uniform vec4 light_2_color = vec4(0,0,0,0);
uniform float light_2_glow = 1.0f;
uniform vec3 light_3_position = vec3(0,0,0);
uniform vec4 light_3_color = vec4(0,0,0,0);
uniform float light_3_glow = 1.0f;
uniform vec3 light_4_position = vec3(0,0,0);
uniform vec4 light_4_color = vec4(0,0,0,0);
uniform float light_4_glow = 1.0f;
uniform vec3 light_5_position = vec3(0,0,0);
uniform vec4 light_5_color = vec4(0,0,0,0);
uniform float light_5_glow = 1.0f;
uniform vec3 light_6_position = vec3(0,0,0);
uniform vec4 light_6_color = vec4(0,0,0,0);
uniform float light_6_glow = 1.0f;
uniform vec3 light_7_position = vec3(0,0,0);
uniform vec4 light_7_color = vec4(0,0,0,0);
uniform float light_7_glow = 1.0f;
uniform vec3 light_8_position = vec3(0,0,0);
uniform vec4 light_8_color = vec4(0,0,0,0);
uniform float light_8_glow = 1.0f;
uniform vec3 light_9_position = vec3(0,0,0);
uniform vec4 light_9_color = vec4(0,0,0,0);                                    
uniform float light_9_glow = 1.0f;

// will store the 3d position of the fragment
vec3 frag_pos; 
       
// calc the strength of a light for a given pixel
vec3 calc_light(vec3 light_pos, vec4 light_color, vec4 normal, float light_glow)
{
        // get vector from light source to frag
        vec3 positionToLightSource = light_pos - frag_pos;
        float distance_fac = length(positionToLightSource);
       
        // calc distance factor
        float str = (light_color.a * 10000.0) / (pow(distance_fac, 2) * pow(lights_size_factor, 2)) / (100.0f * light_color.a);
       
        // wrap value and calc normal map factor
        positionToLightSource.y *= -1.0;
        positionToLightSource = normalize(positionToLightSource).xyz * (specular * light_glow);
        str = min(1, str) * (max(dot(normal.xyz, positionToLightSource.xyz), 0.0));
       
        // return light strength on fragment
        return light_color.rgb * str;
}
                                                       
////////////////////////////////////////////////
// main loop
////////////////////////////////////////////////
void main()
{

    // get fragment texture and normal
    vec4 pixel = texture2D(texture, gl_TexCoord[0].xy);
       
        // if invisible stop here
        if (pixel.a * gl_Color.a == 0.0f)
        {
                gl_FragColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
                return;
        }
       
        vec4 normal = texture2D(normal_map, gl_TexCoord[0].xy);

        // get the 3d position of the current fragment
        // IMPORTANT NOTICE: X AND Y THE POSITION, Z IS HEIGHT ABOVE THE FLOOR
        frag_pos = vec3(gl_FragCoord.x, gl_FragCoord.y, 0);    
        frag_pos.z = (normal.a - 0.5f) * 50.0;
       
       
        // fix normal
        normal = normalize(normal - 0.5);
       
        // calculate light on this fragment
        vec4 light_str = vec4(0,0,0,1);
        if (light_0_color.a > 0) light_str.rgb += calc_light(light_0_position, light_0_color, normal, light_0_glow);
        if (light_1_color.a > 0) light_str.rgb += calc_light(light_1_position, light_1_color, normal, light_1_glow);
        if (light_2_color.a > 0) light_str.rgb += calc_light(light_2_position, light_2_color, normal, light_2_glow);
        if (light_3_color.a > 0) light_str.rgb += calc_light(light_3_position, light_3_color, normal, light_3_glow);
        if (light_4_color.a > 0) light_str.rgb += calc_light(light_4_position, light_4_color, normal, light_4_glow);
        if (light_5_color.a > 0) light_str.rgb += calc_light(light_5_position, light_5_color, normal, light_5_glow);
        if (light_6_color.a > 0) light_str.rgb += calc_light(light_6_position, light_6_color, normal, light_6_glow);
        if (light_7_color.a > 0) light_str.rgb += calc_light(light_7_position, light_7_color, normal, light_7_glow);
        if (light_8_color.a > 0) light_str.rgb += calc_light(light_8_position, light_8_color, normal, light_8_glow);
        if (light_9_color.a > 0) light_str.rgb += calc_light(light_9_position, light_9_color, normal, light_9_glow);
        light_str.rgb += light_ambient_color;
        light_str = (floor(light_str * 3.5f) / 3.5f);
        light_str.a = 1.0f; // so we won't effect opacity due to lighting
       
    // calculate the output color: vertex color * texture * light
    gl_FragColor = gl_Color * pixel * light_str;
}
 

excuse those ugly copy-pastas, its because (as far as I know) sfml can't set array of uniforms or structs.
anyway in the cpp side I do something like this to set a light:

void Graphics::add_light(const SLight& light, unsigned int index)
{
        // fix light position
        sf::Vector2f pos(light.position.x, light.position.y);
        pos = (sf::Vector2f)m_window.mapCoordsToPixel(pos, m_view);
        sf::Vector3f pos_convert(pos.x, get_window_size().y - pos.y, light.position.z);

        // set light params
        m_shader.setParameter("light_" + std::to_string((long long)index) + "_position", pos_convert);
        m_shader.setParameter("light_" + std::to_string((long long)index) + "_glow", light.glow);
        m_shader.setParameter("light_" + std::to_string((long long)index) + "_color", light.color);
}