Let There Be Light 2

[Hapax]

Is there a way to only draw the lights for each lightSystem and not the dark parts? 

You could try drawing the second one using an additive blend mode.
See BlendMode documentation.

[Guido_Ion]

Thanks for the answer, but that didn't work, it still draws the dark parts twice and the lights very strong, that's not the result I want.
Maybe I need to create other sprites (penumbraTexture.png, etc.) with the dark parts as transparent for the second lightsystem. I don't know how to do that but I'll mess around with GIMP and see what's the result.

If lolz or someone has another easy answer for using 2 light systems it would be great.

[grzyboleusz]

Hello, I've been using SFML for quite a while, but stumbled upon this gem of a library a few days ago.

I have successfully integrated Alia5's version of LTBL2 and I am VERY pleased with it but there's 1 thing missing for me to achive what I want:
I'd love to have a directional light source to interact with normal/specular maps - a way to lit the surface of every object drawn to normal map buffer from given angle, a kind of global light source.
I suspect it can be done after every other light source is drawn with slight modification of existing shaders, but currently it's beyond me. If I'll manage to do it I'll post it here, but feel free to be first if it's no biggie to you 

Many thanks to everyone involved in this project and SFML itself.

[grzyboleusz]

As I said, there it is:

Shader to add global directional lighting, every pixel is lit from given direction vector without cosidering the distance (slightly modified version of the one included in the library, I only use it to draw light with additive blending):

(click to show/hide)

uniform sampler2D normalTexture;
uniform sampler2D specularTexture;
uniform float lightPower;
uniform vec3 lightColor;
uniform vec3 lightDirection;
uniform vec2 targetSize;
 
void main()
{
        vec2 coord = gl_TexCoord[0].xy;
        vec4 specMap = texture2D(specularTexture, gl_FragCoord.xy / targetSize, 1.0);
        vec3 normalColor = texture2D(normalTexture, gl_FragCoord.xy / targetSize).rgb;
        vec3 normal = normalize(normalColor * 2.0 - 1.0);
        vec3 lightDir = normalize(lightDirection);
        float colorIntensity = max(dot(normal, lightDir), 0.0);
        vec4 specular = vec4(0.0);
        float lightSpecPower = (specMap.r + specMap.g + specMap.b) * lightPower;
        vec4 lightSpecColor = vec4(vec4(lightColor, 1.0) * specMap);
        if (colorIntensity > 0.0)
        {
                vec4 specColor = specMap;
                vec3 reflectDir = reflect(-lightDir, normal);
                float specModifier = max(dot(reflectDir, lightDir), 0.0);
                specular = pow(specModifier, lightSpecPower) * specColor * lightSpecColor;
                specular.a = 1.0;
        }
        gl_FragColor = clamp(specular, 0.0, 1.0);
}
 

Also, I needed a shader to correct rotated normal maps of the sprites so there it is:

(click to show/hide)

#version 120

uniform sampler2D texture;

const float TAU = 6.28318530718;

void main()
{
        float angle = gl_Color.b * TAU;
        vec2 rotation = vec2(cos(angle), sin(angle));
        mat3x3 rot_matrix = mat3x3(vec3(rotation.x, -rotation.y, 0.0), vec3(rotation.y, rotation.x, 0.0), vec3(0.0, 0.0, 1.0));
        vec4 normalsColor = texture2D(texture, gl_TexCoord[0].xy);
        if (gl_Color.r < 1.0)
                normalsColor.r = 1.0 - normalsColor.r;
        if (gl_Color.g < 1.0)
                normalsColor.g = 1.0 - normalsColor.g;
        vec3 normals = normalize(normalsColor.rgb * 2.0 - 1.0);
        normals = normals * rot_matrix;
        vec4 result = vec4((normals.rgb + 1.0) * 0.5, normalsColor.a);
        gl_FragColor = clamp(result, 0.0, 1.0);
}
 

As you can see, it uses vertex color channels to represent rotation and flipping, so you dont have to set any uniforms while drawing - useful for collective VertexArrays
Red color - if lower than 1.0 (or 255 in sf::Color) flips the normal map horizontally
Green  color - if lower than 1.0 (or 255 in sf::Color) flips the normal map vertically
Blue color - is angle in radians divided by Tau (2 * Pi)
Simply use it to draw normal maps

[Yuri]

Hello

I have problem thats my light point emmision is only a half of circle and i dont know how to fix it :/
I use fallowing code with Alia5 LTBL2:

Code: [Select]

#include "ltbl/lighting/LightSystem.hpp"
#include <SFML/Graphics.hpp>
#include <iostream>


int main() {
    sf::RenderTexture normal_texture_;
    sf::RenderTexture specular_texture_;
    sf::RenderWindow window{sf::VideoMode{800,600}, "LightShow"};
    ltbl::LightSystem lightSystem{normal_texture_,specular_texture_,true};
    lightSystem.create({ -1000.f, -1000.f, 1000.f, 1000.f }, window.getSize());


    sf::Texture pointLightTexture;
    pointLightTexture.loadFromFile("resources/pointLightTexture.png");
    pointLightTexture.setSmooth(true);


    auto* light = lightSystem.createLightPointEmission();
    light->setTexture(pointLightTexture);
    light->setOrigin(pointLightTexture.getSize().x / 2.f, pointLightTexture.getSize().y / 2.f);
    light->setScale(10.f,10.f);


    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }
        sf::Vector2f pos(sf::Mouse::getPosition(window));
        light->setPosition(pos);


        window.clear(sf::Color::White);
        lightSystem.render(window);
        window.display();
    }
    return 0;
}any tips?

edit: dummy me
 ltbl::LightSystem lightSystem{normal_texture_,specular_texture_,FALSE};