render_opengl: Use new shadowing algorithm in fragment shader fallback

Also lower minimum OpenGL requirement to 3.1.

Author: caseif

engine/modules/render/res/render/shader/lighting_frag.frag

@@ -2,11 +2,6 @@
 
 #extension GL_ARB_compute_shader : enable
 
-// fallback fragment shader currently uses atomics which don't support floats
-#ifdef GL_ARB_compute_shader
-#define IS_RAY_BUFFER_FLOAT 1
-#endif
-
 #define PI 3.14159
 #define TWO_PI (PI * 2.0)
 
@@ -35,11 +30,7 @@ in vec2 TexCoord;
 
 out vec4 out_Color;
 
-#ifdef IS_RAY_BUFFER_FLOAT
-layout(binding = 0) uniform samplerBuffer u_RayBuffer;
-#else
-layout(binding = 0) uniform usamplerBuffer u_RayBuffer;
-#endif
+layout(binding = 0) uniform sampler2D u_ShadowMap;
 
 layout(std140, binding = 0) uniform Scene {
     vec4 AmbientLightColor;
@@ -53,17 +44,6 @@ layout(std140, binding = 1) uniform Viewport {
     Light2D Lights[32];
 } viewport;
 
-// annoying workaround bc our GLSL parser chokes on mid-function macros
-#ifdef IS_RAY_BUFFER_FLOAT
-float fetch_occl_dist(int ray_index) {
-    return texelFetch(u_RayBuffer, ray_index).r;
-}
-#else
-float fetch_occl_dist(int ray_index) {
-    return texelFetch(u_RayBuffer, ray_index).r / float(DIST_MULTIPLIER);
-}
-#endif
-
 // Applies a power-like function with a non-integer exponent without doing an
 // expensive pow() operation.
 //
@@ -123,8 +103,7 @@ void main() {
         bool is_occluded = false;
         float occl_dist;
         if (light.is_occludable != 0U) {
-            int ray_lookup_index = int(i * RAY_COUNT + ray_index);
-            occl_dist = fetch_occl_dist(ray_lookup_index);
+            occl_dist = texelFetch(u_ShadowMap, ivec2(ray_index, i), 0).r;
             is_occluded = dist >= occl_dist;
         }
 

engine/modules/render/res/render/shader/shadowmap_comp.comp

@@ -34,7 +34,7 @@ layout(std140, binding = 3) uniform Viewport {
 } viewport;
 
 layout(binding = 0) uniform sampler2D u_OpacityMap;
-layout(binding = 0, r32f) uniform imageBuffer u_RayBuffer;
+layout(binding = 0, r32f) uniform image2D u_ShadowMap;
 
 vec2 world_to_uv(vec2 world_pos) {
     return (viewport.ViewMatrix * vec4(world_pos, 0.0, 1.0)).xy * 0.5 + 0.5;
@@ -45,21 +45,21 @@ vec2 uv_to_world(vec2 uv) {
 }
 
 void main() {
-    ivec2 map_size = textureSize(u_OpacityMap, 0);
     uint global_index = gl_GlobalInvocationID.x;
     uint light_index = global_index / RAY_COUNT;
-    uint ray_index = global_index % RAY_COUNT;
 
     if (light_index >= viewport.LightCount) {
         return;
     }
 
     Light2D light = viewport.Lights[light_index];
     if (light.is_occludable == 0U) {
-        imageStore(u_RayBuffer, int(global_index), vec4(FLOAT_MAX, 0.0, 0.0, 0.0));
         return;
     }
 
+    uint ray_index = global_index % RAY_COUNT;
+    ivec2 dest_coord = ivec2(ray_index, light_index);
+
     vec2 light_pos_uv = world_to_uv(light.position.xy);
 
     float theta = float(ray_index) * TWO_PI / float(RAY_COUNT) - PI;
@@ -82,14 +82,15 @@ void main() {
     float t_exit  = min(t_max.x, t_max.y);
 
     if (t_enter > t_exit) {
-        imageStore(u_RayBuffer, int(global_index), vec4(FLOAT_MAX, 0.0, 0.0, 0.0));
+        imageStore(u_ShadowMap, dest_coord, vec4(FLOAT_MAX, 0.0, 0.0, 0.0));
         return;
     }
 
+    ivec2 map_size = textureSize(u_OpacityMap, 0);
+
     float nearest = FLOAT_MAX;
     ivec2 last_texel = ivec2(-1);
     float step_uv = 1.0 / float(max(map_size.x, map_size.y));
-    bool did_sample_in_frame = false;
     float t_end = min(t_exit, max_uv_dist);
     for (float dist_uv = t_enter; dist_uv <= t_end; dist_uv += step_uv) {
         vec2 sample_uv = light_pos_uv + dir_uv_unit * dist_uv;
@@ -103,8 +104,6 @@ void main() {
         }
         last_texel = sample_texel;
 
-        did_sample_in_frame = true;
-
         if (texelFetch(u_OpacityMap, sample_texel, 0).r > 0.0) {
             // pixel is opaque to light
             vec2 sample_world = uv_to_world(sample_uv);
@@ -116,5 +115,5 @@ void main() {
         // else pixel is transparent to light; continue marching
     }
 
-    imageStore(u_RayBuffer, int(global_index), vec4(nearest, 0.0, 0.0, 0.0));
+    imageStore(u_ShadowMap, dest_coord, vec4(nearest, 0.0, 0.0, 0.0));
 }

engine/modules/render/res/render/shader/shadowmap_frag.frag

@@ -2,6 +2,7 @@
 
 #define PI 3.14159
 #define TWO_PI (PI * 2.0)
+#define FLOAT_MAX 3.402823e38
 
 #define LIGHTS_MAX 32
 #define RAY_COUNT 360
@@ -29,7 +30,6 @@ in vec2 TexCoord;
 out vec4 out_Color;
 
 layout(binding = 0) uniform sampler2D u_OpacityMap;
-layout(binding = 0, r32ui) uniform uimageBuffer u_RayBuffer;
 
 layout(std140, binding = 2) uniform Scene {
     vec4 AmbientLightColor;
@@ -43,38 +43,87 @@ layout(std140, binding = 3) uniform Viewport {
     Light2D Lights[32];
 } viewport;
 
+vec2 world_to_uv(vec2 world_pos) {
+    return (viewport.ViewMatrix * vec4(world_pos, 0.0, 1.0)).xy * 0.5 + 0.5;
+}
+
+vec2 uv_to_world(vec2 uv) {
+    return (viewport.ViewMatrixInverse * vec4(uv * 2.0 - 1.0, 0.0, 1.0)).xy;
+}
+
 void main() {
-    if (viewport.LightCount == 0) {
+    int buf_len = LIGHTS_MAX * RAY_COUNT;
+    int global_index = int(TexCoord.x * buf_len);
+    uint light_index = uint(TexCoord.y * LIGHTS_MAX);
+
+    if (light_index >= viewport.LightCount) {
         discard;
     }
 
-    if (texture(u_OpacityMap, TexCoord).r == 0.0) {
-        // pixel is transparent to light
+    Light2D light = viewport.Lights[light_index];
+    if (light.is_occludable == 0U) {
         discard;
     }
 
-    for (int i = 0; i < LIGHTS_MAX; i++) {
-        if (i >= viewport.LightCount) {
-            break;
-        }
+    uint ray_index = uint(TexCoord.x * RAY_COUNT);
+
+    vec2 light_pos_uv = world_to_uv(light.position.xy);
+
+    float theta = float(ray_index) * TWO_PI / float(RAY_COUNT) - PI;
+    vec2 dir_world = vec2(cos(theta), sin(theta));
+    vec2 dir_uv = (viewport.ViewMatrix * vec4(dir_world, 0.0, 0.0)).xy;
+    vec2 dir_uv_unit = normalize(dir_uv);
+
+    float max_world_dist = light.falloff_buffer + light.falloff_distance + light.shadow_falloff_distance;
+    float max_uv_dist = max_world_dist * length(dir_uv) * 0.5;
+
+    vec2 inv_dir = 1.0 / dir_uv_unit;
+
+    vec2 t0 = (vec2(0.0) - light_pos_uv) * inv_dir;
+    vec2 t1 = (vec2(1.0) - light_pos_uv) * inv_dir;
 
-        Light2D light = viewport.Lights[i];
-        vec2 light_pos = light.position.xy;
-        vec2 offset = WorldPos.xy - light_pos;
+    vec2 t_min = min(t0, t1);
+    vec2 t_max = max(t0, t1);
 
-        if (abs(offset.x) < 0.01 && abs(offset.y) < 0.01) {
-            // light is fully occluded
-            for (int j = 0; j < RAY_COUNT; j++) {
-                imageAtomicExchange(u_RayBuffer, int(i * RAY_COUNT + j), 0);
-            }
+    float t_enter = max(max(t_min.x, t_min.y), 0.0);
+    float t_exit  = min(t_max.x, t_max.y);
+
+    if (t_enter > t_exit) {
+        out_Color = vec4(FLOAT_MAX, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    ivec2 map_size = textureSize(u_OpacityMap, 0);
+
+    float nearest = FLOAT_MAX;
+    ivec2 last_texel = ivec2(-1);
+    float step_uv = 1.0 / float(max(map_size.x, map_size.y));
+    bool did_sample_in_frame = false;
+    float t_end = min(t_exit, max_uv_dist);
+    for (float dist_uv = t_enter; dist_uv <= t_end; dist_uv += step_uv) {
+        vec2 sample_uv = light_pos_uv + dir_uv_unit * dist_uv;
+        if (sample_uv.x <= 0.0 || sample_uv.y <= 0.0 || sample_uv.x >= 1.0 || sample_uv.y >= 1.0) {
             continue;
         }
 
-        float theta = atan(offset.y, offset.x) + PI;
-        uint ray_index = uint(floor(float(RAY_COUNT) * theta / TWO_PI));
-        uint dist = uint(distance(light_pos, WorldPos.xy) * DIST_MULTIPLIER);
-        imageAtomicMin(u_RayBuffer, int(i * RAY_COUNT + ray_index), dist);
+        ivec2 sample_texel = ivec2(sample_uv * vec2(map_size));
+        if (sample_texel == last_texel) {
+            continue;
+        }
+        last_texel = sample_texel;
+
+        did_sample_in_frame = true;
+
+        if (texelFetch(u_OpacityMap, sample_texel, 0).r > 0.0) {
+            // pixel is opaque to light
+            vec2 sample_world = uv_to_world(sample_uv);
+            float dist_world = distance(sample_world, light.position.xy);
+            nearest = dist_world;
+            break;
+        }
+
+        // else pixel is transparent to light; continue marching
     }
 
-    discard;
+    out_Color = vec4(nearest, 0.0, 0.0, 0.0);
 }

engine/modules/render/src/constants.rs

@@ -54,7 +54,7 @@ pub const SHADER_UNIFORM_GLOBAL_TIME: &str = "Time";
 pub const SHADER_UNIFORM_GLOBAL_TIME_OFF: u32 = 0;
 
 pub const SHADER_UBO_SCENE: &str = "Scene";
-pub const SHADER_UBO_SCENE_LEN: u32 = 48 + (SHADER_STRUCT_LIGHT2D_LEN * LIGHTS_MAX);
+pub const SHADER_UBO_SCENE_LEN: u32 = 20;
 pub const SHADER_UNIFORM_SCENE_AL_COLOR: &str = "AmbientLightColor";
 pub const SHADER_UNIFORM_SCENE_AL_COLOR_OFF: u32 = 0;
 pub const SHADER_UNIFORM_SCENE_AL_LEVEL: &str = "AmbientLightLevel";