TEMP

assets/shaders/gi_post_processing.wgsl

@@ -37,11 +37,14 @@ fn fragment(
     let in_walls_diffuse   = textureSample(in_walls_texture,   in_walls_sampler, uv).xyz;
     let in_objects_diffuse = textureSample(in_objects_texture, in_objects_sampler, uv).xyz;
 
-//    let irradiance = textureSample(in_irradiance_texture, in_irradiance_texture_sampler, uv).xyz;
-//    let out_color = diffuse * lin_to_srgb(irradiance);
+    let in_irradiance = textureSample(in_irradiance_texture, in_irradiance_texture_sampler, uv).xyz;
 
 
-    let out = (in_floor_diffuse + in_walls_diffuse + in_objects_diffuse).xyz;
+
+    let floor_final_rgb = in_floor_diffuse * lin_to_srgb(in_irradiance);
+
+
+    let out = floor_final_rgb;
 
     return vec4<f32>(out, 1.0);
 }

assets/shaders/gi_sdf.wgsl

@@ -12,7 +12,7 @@ fn sdf_aabb_occluder(p: vec2<f32>, occluder_i: i32) -> f32 {
     let local_p = quat_mul(occluder.rotation, vec3<f32>(local_p, 0.0)).xy;
     let d        = abs(local_p) - occluder.h_extent;
     let d_max    = max(d, vec2<f32>(0.0));
-    let d_o      = fast_length_2d(d_max);
+    let d_o      = length(d_max);
     let d_i      = min(max(d.x, d.y), 0.0);
     return d_o + d_i;
 }

assets/shaders/gi_ss_filter.wgsl

@@ -83,8 +83,8 @@ fn main(@builtin(global_invocation_id) invocation_id: vec3<u32>) {
                 continue;
             }
 
-            let d = fast_distance_2d(p_world_pose, sample_world_pose);
-            let x = fast_distance_3d(p_sample, base_probe_sample);
+            let d = distance(p_world_pose, sample_world_pose);
+            let x = distance(p_sample, base_probe_sample);
             let g = gauss(x) * gauss(d);
 
             total_q += p_sample * g;

assets/shaders/gi_ss_probe.wgsl

@@ -27,32 +27,21 @@ fn raymarch_primary(
 
     var ray_origin  = ray_origin;
     var ray_target  = ray_target;
-    let target_uv   = world_to_sdf_uv(ray_target, camera_params.view_proj, camera_params.inv_sdf_scale);
-    let target_dist = bilinear_sample_r(sdf, sdf_sampler, target_uv);
 
-    if (target_dist < 0.0) {
-        let temp = ray_target;
-        ray_target = ray_origin;
-        ray_origin = temp;
-    }
-
-    let ray_direction          = fast_normalize_2d(ray_target - ray_origin);
+    let ray_direction          = normalize(ray_target - ray_origin);
     let stop_at                = distance_squared(ray_origin, ray_target);
 
     var ray_progress:   f32    = 0.0;
     var h                      = vec2<f32>(0.0);
     var h_prev                 = h;
-    let min_sdf                = 0.5;
-    var inside                 = true;
-    let max_inside_dist        = 20.0;
-    let max_inside_dist_sq     = max_inside_dist * max_inside_dist;
+    let min_sdf                = 1e-4;
 
     for (var i: i32 = 0; i < max_steps; i++) {
 
         h_prev = h;
         h = ray_origin + ray_progress * ray_direction;
 
-        if ((ray_progress * ray_progress >= stop_at) || (inside && (ray_progress * ray_progress > max_inside_dist))) {
+        if ray_progress * ray_progress >= stop_at {
             return RayMarchResult(1, i, h_prev);
         }
 
@@ -63,13 +52,11 @@ fn raymarch_primary(
         }
 
         let scene_dist = bilinear_sample_r(sdf, sdf_sampler, uv);
-        if ((scene_dist <= min_sdf && !inside)) {
+        if scene_dist <= min_sdf {
             return RayMarchResult(0, i, h);
         }
-        if (scene_dist > 0.0) {
-            inside = false;
-        }
-        let ray_travel = max(abs(scene_dist), 0.5);
+
+        let ray_travel = max(abs(scene_dist), 0.0);
 
         ray_progress += ray_travel * (1.0 - rm_jitter_contrib) + rm_jitter_contrib * ray_travel * hash(h);
    }
@@ -92,12 +79,13 @@ fn main(@builtin(global_invocation_id) invocation_id: vec3<u32>) {
 
     // Get current frame.
     let probe_offset_world  = halton_jitter * probe_size_f32;
-    let probe_center_world  = screen_to_world(
-        probe_tile_origin_screen,
-        camera_params.screen_size,
-        camera_params.inverse_view_proj,
-        camera_params.screen_size_inv,
-    ) + probe_offset_world;
+    let probe_center_world_unbiased = screen_to_world(
+                                              probe_tile_origin_screen,
+                                              camera_params.screen_size,
+                                              camera_params.inverse_view_proj,
+                                              camera_params.screen_size_inv,
+                                          );
+    let probe_center_world  =  probe_center_world_unbiased + probe_offset_world;
 
     let probe_ndc    = world_to_ndc(probe_center_world, camera_params.view_proj);
     let probe_screen = ndc_to_screen(probe_ndc, camera_params.screen_size);
@@ -117,7 +105,7 @@ fn main(@builtin(global_invocation_id) invocation_id: vec3<u32>) {
 
     var probe_irradiance = vec3<f32>(0.0);
 
-    let uv = world_to_sdf_uv(probe_center_world, camera_params.view_proj, camera_params.inv_sdf_scale);
+    let uv = world_to_sdf_uv(probe_center_world_unbiased, camera_params.view_proj, camera_params.inv_sdf_scale);
     let dist = bilinear_sample_r( sdf_in, sdf_in_sampler, uv);
     if dist > 0.0 {
 

examples/krypta.rs

@@ -515,6 +515,7 @@ fn setup(
                         },
                         ..default()
                     })
+                    .insert(RenderLayers::all())
                     .id();
             };
 
@@ -716,6 +717,7 @@ fn setup(
             falloff:   Vec3::new(50.0, 20.0, 0.05),
             ..default()
         })
+        .insert(RenderLayers::all())
         .insert(MouseLight);
 
     let (floor_target, walls_target, objects_target) = post_processing_target
@@ -739,7 +741,7 @@ fn setup(
             Name::new("main_camera_floor"),
         ))
         .insert(SpriteCamera)
-        .insert(ObjectsCamera)
+        .insert(FloorCamera)
         .insert(RenderLayers::from_layers(CAMERA_LAYER_FLOOR))
         .insert(UiCameraConfig {
             show_ui: false,
@@ -847,32 +849,36 @@ fn system_control_mouse_light(
 
 #[rustfmt::skip]
 fn system_move_camera(
-    mut camera_target: Local<Vec3>,
+    mut camera_current: Local<Vec2>,
+    mut camera_target:  Local<Vec2>,
     mut query_cameras:  Query<&mut Transform, With<SpriteCamera>>,
-        keyboard:      Res<Input<KeyCode>>,
+        keyboard:       Res<Input<KeyCode>>,
 ) {
 
-    // Update all sprite cameras.
-    for mut camera_transform in query_cameras.iter_mut() {
-        let speed = 10.0;
+    let speed = 10.0;
 
-        if keyboard.pressed(KeyCode::W) {
-            camera_target.y += speed;
-        }
-        if keyboard.pressed(KeyCode::S) {
-            camera_target.y -= speed;
-        }
-        if keyboard.pressed(KeyCode::A) {
-            camera_target.x -= speed;
-        }
-        if keyboard.pressed(KeyCode::D) {
-            camera_target.x += speed;
-        }
+    if keyboard.pressed(KeyCode::W) {
+        camera_target.y += speed;
+    }
+    if keyboard.pressed(KeyCode::S) {
+        camera_target.y -= speed;
+    }
+    if keyboard.pressed(KeyCode::A) {
+        camera_target.x -= speed;
+    }
+    if keyboard.pressed(KeyCode::D) {
+        camera_target.x += speed;
+    }
 
-        // Smooth camera.
-        let blend_ratio = 0.18;
-        let movement    = (*camera_target - camera_transform.translation) * blend_ratio;
-        camera_transform.translation.x += movement.x;
-        camera_transform.translation.y += movement.y;
+    // Smooth camera.
+    let blend_ratio = 0.18;
+    let movement = *camera_target - *camera_current;
+    *camera_current += movement * blend_ratio;
+
+    // Update all sprite cameras.
+    for mut camera_transform in query_cameras.iter_mut() {
+        camera_transform.translation.x = camera_current.x;
+        camera_transform.translation.y = camera_current.y;
     }
 }
+

src/gi/pipeline_assets.rs

@@ -13,7 +13,7 @@ use crate::gi::types_gpu::{
     GpuSkylightMaskData,
 };
 use crate::prelude::BevyMagicLight2DSettings;
-use crate::SpriteCamera;
+use crate::FloorCamera;
 
 #[rustfmt::skip]
 #[derive(Default, Resource)]
@@ -53,7 +53,7 @@ pub(crate) fn system_extract_pipeline_assets(
 
     query_lights:               Extract<Query<(&Transform, &OmniLightSource2D, &ComputedVisibility)>>,
     query_occluders:            Extract<Query<(&LightOccluder2D, &Transform, &ComputedVisibility)>>,
-    query_camera:               Extract<Query<(&Camera, &GlobalTransform), With<SpriteCamera>>>,
+    query_camera:               Extract<Query<(&Camera, &GlobalTransform), With<FloorCamera>>>,
     query_masks:                Extract<Query<(&Transform, &SkylightMask2D)>>,
     query_skylight_light:       Extract<Query<&SkylightLight2D>>,
 
@@ -138,13 +138,14 @@ pub(crate) fn system_extract_pipeline_assets(
             );
 
             let scale = 2.0;
-            camera_params.sdf_scale = Vec2::splat(scale);
+            camera_params.sdf_scale     = Vec2::splat(scale);
             camera_params.inv_sdf_scale = Vec2::splat(1. / scale);
 
             let probes = gpu_pipeline_assets.probes.get_mut();
             probes.data[*gpu_frame_counter as usize].camera_pose =
                 camera_global_transform.translation().truncate();
         } else {
+            log::warn!("Failed to get camera");
             let probes = gpu_pipeline_assets.probes.get_mut();
             probes.data[*gpu_frame_counter as usize].camera_pose = Vec2::ZERO;
         }

src/lib.rs

@@ -6,8 +6,8 @@ pub mod prelude;
 #[derive(Component)]
 pub struct SpriteCamera;
 #[derive(Component)]
-pub struct ObjectsCamera;
+pub struct FloorCamera;
 #[derive(Component)]
 pub struct WallsCamera;
 #[derive(Component)]
-pub struct ObjectCamera;
+pub struct ObjectsCamera;

src/prelude.rs

@@ -2,5 +2,5 @@ pub use crate::gi::compositing::{setup_post_processing_camera, PostProcessingTar
 pub use crate::gi::resource::{BevyMagicLight2DSettings, LightPassParams};
 pub use crate::gi::types::{LightOccluder2D, OmniLightSource2D, SkylightLight2D, SkylightMask2D};
 pub use crate::gi::BevyMagicLight2DPlugin;
-pub use crate::{SpriteCamera, ObjectsCamera, WallsCamera, ObjectCamera};
+pub use crate::{SpriteCamera, FloorCamera, WallsCamera, ObjectsCamera};
 pub use crate::gi::render_layer::{CAMERA_LAYER_FLOOR, CAMERA_LAYER_OBJECTS, CAMERA_LAYER_WALLS};