Add dynamic 2D global illumination system

[demolen]

Describe the project you are working on

Applies to any 2d Game

Describe the problem or limitation you are having in your project

There are currently no out-of-the-box GI solution present for 2D in Godot

Describe the feature / enhancement and how it helps to overcome the problem or limitation

Using SDF ray-marching and screen space irradiance cache probes it is possible to get relatively cheap 2D GI

Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams

take a look here:
https://github.com/zaycev/bevy-magic-light-2d/tree/main
https://www.youtube.com/watch?v=swljK4Isc6g

If this enhancement will not be used often, can it be worked around with a few lines of script?

Of course it is possible to leave it to the users to implement their own GI, but considering the complexity, It would be too optimistic that a typical user could.

Is there a reason why this should be core and not an add-on in the asset library?

Actually not. But we have GI out of the box for 3D, why not 2d?

[Calinou]

Moving to discussion, as there is no concrete technical implementation provided.¹

Note that it's already possible to do this in Godot using custom shaders. You can see an example in 3.x here, but 4.x makes this much easier with SDF generation and access in CanvasItem shaders. I believe I've already seen this implemented by plugins in 4.x, but I can't find any right now.

Footnotes

1. Linking to implementations in other languages is appreciated, but implementing 2D GI in Godot is not a simple copy-paste job (especially from a non-C++ language). Therefore, we expect proposal issues to have things like a proposed scripting API design, a list of nodes/properties that would be added to let users configure 2D GI and so on. If you don't have a definitive idea on this yet, this is where discussions come in. ↩

[demolen]

I'm aware of the 3.0 implementations you've mentioned however -to my tests- it's not well suited for using in realtime. And actually as it no longer works in godot 4.0, it is a good reason why it'd be better to have this as a part of the main engine code, so that it would be maintained and iterated over by the community over each release or major change in rendering and also for performance, etc...
with that being said unfortunately I cannot help further with this regarding implementation or an outline of it since I'm simply the wrong person for this. Such advanced graphics Programming is overshooting my humble abilities and time schedule. For whomever that would eventually pick this up, the bevy implementation mentioned above and the following shader toys are the most performant implementations I've seen somewhere. don't ask me about them though.
https://www.shadertoy.com/view/cs3XzS
https://www.shadertoy.com/view/dd2BDc
https://www.shadertoy.com/view/NttSW7
https://www.shadertoy.com/view/dlcXR4

[scgm0]

Moving to discussion, as there is no concrete technical implementation provided.1

Note that it's already possible to do this in Godot using custom shaders. You can see an example in 3.x here, but 4.x makes this much easier with SDF generation and access in CanvasItem shaders. I believe I've already seen this implemented by plugins in 4.x, but I can't find any right now.

Footnotes

1. Linking to implementations in other languages is appreciated, but implementing 2D GI in Godot is not a simple copy-paste job (especially from a non-C++ language). Therefore, we expect proposal _issues_ to have things like a proposed scripting API design, a list of nodes/properties that would be added to let users configure 2D GI and so on. If you don't have a definitive idea on this yet, this is where discussions come in. [↩](#user-content-fnref-1-8c29151029fdcb445892a55921686580)

This should be an example of 4.x?
https://godotshaders.com/shader/drop-in-pbr-2d-lighting-system-with-soft-shadows-and-ambient-occlusion/
https://github.com/Oman395/godot-better-lighting-2d

[demolen]

I'm aware of the godot better lighting 2d by Oman and indeed in contact with them via email. their implementation is not a GI solution. a small update on the progress: So far I've had already implanted the GI as a screen space effect. However the short coming about screen space normals and specular/roughness made me make my own custom texture data where I use the r channel for indexed diffuse, g channel for the indexed normal, b for specular and a for alpha. I then provide the color palettes to my shader to decode the data it needs. works in my case. but as you read is quite "custom".

[demolen]

I found some time today to look into this again. I've found a shader on shader toy that does a pretty decent job at doing extremely cheap GI https://www.shadertoy.com/view/Xtcfzj and translated it into godot shader language:

//GI shader
shader_type canvas_item;
render_mode unshaded;
uniform vec2 resolution = vec2(320.0, 180.0);
#define SAMPLES 32.0
#define bayerZoom mix(0.5, 8.0, .1 * 0.5 + 0.5)
#define iterBayerMat 2
#define ViewZoom 8.0
#define iResolution resolution
#define pi 3.14159265359
#define cs(a) vec2(cos(a), sin(a))

float boxSignedDistanceField(vec2 point, vec2 size) {
    vec2 distanceToEdges = abs(point) - size;
    return min(max(distanceToEdges.x, distanceToEdges.y), 0.0) + length(max(distanceToEdges, vec2(0)));
}

void addObject(inout float minDist, inout vec3 objectColor, float dist, vec3 color) {
    if (minDist > dist) {
        minDist = dist;
        objectColor = color;
    }
}

vec4 sceneDescription(vec2 uv) {
    float minDist = 1e9;
    vec3 objectColor = vec3(0);
    addObject(minDist, objectColor, boxSignedDistanceField(uv - vec2(-3, 1), vec2(1, 1)), vec3(0.6, 0.8, 1.0));
    addObject(minDist, objectColor, length(uv - vec2(3, 1)) - 1.0, vec3(1.0, 0.9, 0.8));
    addObject(minDist, objectColor, length(uv - vec2(0.3 * sin(TIME), -2)) - 0.5, vec3(0.0, 0.1, 0.0));
    addObject(minDist, objectColor, boxSignedDistanceField(uv, vec2(1.5, 0.1)), vec3(0.3, 0.1, 0.1));
    return vec4(objectColor, minDist);
}

vec3 rayMarch(vec2 startPos, vec2 direction) {
    for (int i = 55; i > 0; i--) {
        vec4 sceneInfo = sceneDescription(startPos);
        if (sceneInfo.w < 1e-1) return sceneInfo.xyz;
        if (sceneInfo.w > 10.0) return vec3(0);
        startPos += direction * sceneInfo.w;
    }
    return vec3(0);
}

float getBayerValue(vec2 pixelPos) {
    ivec2 p = ivec2(pixelPos);
    int value = 0;
    for (int i = 0; i < iterBayerMat; i++) {
        int shift = iterBayerMat - 1 - i;
        ivec2 b = (p >> shift) & ivec2(1);
        value += (4 - b.x - (b.y << 1)) % 4 << (2 * i);
    }
    return float(value) / float(1 << (iterBayerMat * 2));
}

void fragment() {
    float aspectRatio = resolution.x / resolution.y;
    vec2 uv = UV;
    vec2 adjustedUV = (uv - 0.5) * ViewZoom * vec2(aspectRatio, 1.0);
    vec3 finalColor = vec3(0);
    float phi = sqrt(5.0) * 0.5 - 0.5;
    
    for (float i = 0.0; i < SAMPLES; i++) {
        float scale = 1.0;
        float angle = (i + getBayerValue(bayerZoom * adjustedUV * phi * ViewZoom * iResolution.x + i + 1.61) / scale) / SAMPLES * 2.0 * pi * scale;
        finalColor += rayMarch(adjustedUV, cs(angle));
    }
    
    finalColor /= SAMPLES;
    COLOR = vec4(finalColor * 2.0, 1.0);
}

there are a lot of infos on how it works (better than any way I can explain) on the shader toy page. The next step is to make it generalised by using SDF info provided from godot instead of setting up the scene manually within the shader, e.g. to make it a general purpose godot light shader. I'm trying to figure out how to use light(){} and sdf builtins for the moment. @Calinou If you know anyone that can help me along the way feel welcome to poke them here.

[scgm0]

Maybe check this out: https://godotshaders.com/shader/drop-in-pbr-2d-lighting-system-with-soft-shadows-and-ambient-occlusion/

[demolen]

My answer to your other comment...
:)

[demolen]

Update on this:

I fiddled around and implemented a basic but highly performant 2D GI. however currently due to lack of support of MRT ( Multiple render target, see: #495 ) the solution only does GI based off sdf_texture and doesn't take normals, metallic, roughness, etc... into account.
getting screen space Normals, requires copying every sprite in a subViewport and rendering only their normals. This is also true for lights as they should be rendered in another SubViewport, so that we can differentiate between lights and non emissive objects. I really hate this way of doing this. although possible it's really bad from a design perspective.

Edit:
I just found this godotengine/godot#80214
Will look into it later on today.

[demolen]

A lot of things about the GI work now, including, well the GI itself, dithering (I added two other methods).
Things that doesn’t work:
Speculars (I’m too stupid for this)
Normals (well…see above. I struggle with encoding the position/direction of the lights)
overlapping objects (I don’t even know if it’s possible, maybe having multiple sdf layers would mitigate this)
a way to distinguish between objects, so that they reflect the light differently, something like per object sdf magnification would help maybe)

From here on I give up.
Feel free to fork:

https://github.com/demolen/Godot-2d-GI-test

You need to merge this PR locally to use my code:

Allow using stage functions inside custom shader function