From 1642b13696a037667e4a26c9f47f5b029a523c05 Mon Sep 17 00:00:00 2001
From: glasspangolin <23103433+glasspangolin@users.noreply.github.com>
Date: Mon, 18 Nov 2024 18:04:14 +1100
Subject: [PATCH 1/2] - Updated bevy from 0.12 to 0.14.2 -- Type naming changes
 -- Some fairly large changes with separation of graphics world and game
 world. -- New colours. - WGPU became more fussy: -- Avoiding extreme float
 values NaN, Inf. -- had to change prim raster buffer packing arrangement 64
 bytes to 32 bytes (Rgba32Float x 4 -> Rgba32Float x 1 + Rgba16Float x 2). --
 Seems to be more strict about padding and format of textures. - Attempt to
 avoid type confusion between glam types and spir_v::glam, with conversion
 where necessary. - updated requirement to nightly-2024-04-24 for rust-gpu. --
 Unfortunately, this results in a stubborn: error[E0658]: inline-const is
 experimental Which I found a work around to get a local version of bevy and
 add #![feature(inline_const)] to the crate root.

---
 .gitignore                                    |   1 +
 Cargo.toml                                    |   3 -
 bevy-strolle/Cargo.toml                       |  22 ++--
 bevy-strolle/examples/_common.rs              |  49 +++----
 bevy-strolle/examples/cornell.rs              |   5 +-
 bevy-strolle/examples/demo.rs                 |  62 +++++----
 bevy-strolle/src/debug.rs                     |   3 +-
 bevy-strolle/src/graph.rs                     |  56 ++++----
 bevy-strolle/src/lib.rs                       |   9 +-
 bevy-strolle/src/rendering_node.rs            |   3 +
 bevy-strolle/src/stages.rs                    |   5 +-
 bevy-strolle/src/stages/extract.rs            |  42 ++----
 bevy-strolle/src/stages/prepare.rs            |  79 +++++++-----
 bevy-strolle/src/state.rs                     |   1 -
 bevy-strolle/src/utils.rs                     |  12 +-
 rust-toolchain.toml                           |   4 +-
 strolle-gpu/Cargo.toml                        |   6 +-
 strolle-gpu/src/brdf.rs                       |  12 +-
 strolle-gpu/src/camera.rs                     |   7 +-
 strolle-gpu/src/gbuffer.rs                    | 107 +++++++---------
 strolle-gpu/src/hit.rs                        |   4 +-
 strolle-gpu/src/light.rs                      |  49 ++++---
 strolle-gpu/src/noise/white.rs                |   6 +-
 strolle-gpu/src/ray.rs                        |  24 +++-
 strolle-gpu/src/reservoir/di.rs               |  73 ++++++-----
 strolle-gpu/src/surface.rs                    |  17 ++-
 strolle-gpu/src/triangle.rs                   |   2 +-
 strolle-gpu/src/utils.rs                      |  25 +++-
 strolle-gpu/src/utils/f32_ext.rs              |   2 +-
 strolle-shader-builder/Cargo.toml             |   2 +-
 strolle-shaders/Cargo.toml                    |   2 +-
 strolle-shaders/src/di_resolving.rs           |  21 ++-
 strolle-shaders/src/di_sampling.rs            |   4 +-
 strolle-shaders/src/di_spatial_resampling.rs  |   8 +-
 strolle-shaders/src/di_temporal_resampling.rs |   8 +-
 strolle-shaders/src/frame_composition.rs      |   2 +-
 strolle-shaders/src/frame_denoising.rs        |  12 +-
 strolle-shaders/src/frame_reprojection.rs     |  10 +-
 strolle-shaders/src/gi_preview_resampling.rs  |  11 +-
 strolle-shaders/src/gi_reprojection.rs        |   2 +-
 strolle-shaders/src/gi_resolving.rs           |   2 +-
 strolle-shaders/src/gi_sampling_a.rs          |   2 +-
 strolle-shaders/src/gi_sampling_b.rs          |   4 +-
 strolle-shaders/src/gi_spatial_resampling.rs  |   2 +-
 strolle-shaders/src/gi_temporal_resampling.rs |   4 +-
 strolle-shaders/src/prim_raster.rs            |   7 -
 strolle/Cargo.toml                            |   6 +-
 strolle/src/bvh/builder.rs                    |  11 +-
 strolle/src/bvh/serializer.rs                 |   4 +-
 strolle/src/camera.rs                         |  15 ++-
 strolle/src/camera_controller/buffers.rs      |  64 ++++------
 strolle/src/camera_controller/pass.rs         |   4 +-
 .../camera_controller/passes/bvh_heatmap.rs   |   3 +-
 .../camera_controller/passes/di_resolving.rs  |   3 +-
 .../camera_controller/passes/di_sampling.rs   |   3 +-
 .../passes/di_spatial_resampling.rs           |   7 +-
 .../passes/di_temporal_resampling.rs          |   3 +-
 .../passes/frame_composition.rs               |   6 +-
 .../passes/frame_denoising.rs                 |  17 +--
 .../passes/frame_reprojection.rs              |   7 +-
 .../passes/gi_preview_resampling.rs           |   5 +-
 .../passes/gi_reprojection.rs                 |   3 +-
 .../camera_controller/passes/gi_resolving.rs  |   3 +-
 .../camera_controller/passes/gi_sampling.rs   |   5 +-
 .../passes/gi_spatial_resampling.rs           |   7 +-
 .../passes/gi_temporal_resampling.rs          |   3 +-
 .../camera_controller/passes/prim_raster.rs   |  36 ++----
 .../camera_controller/passes/ref_shading.rs   |   3 +-
 .../camera_controller/passes/ref_tracing.rs   |   3 +-
 strolle/src/images.rs                         | 120 +++++++++++++++---
 strolle/src/lib.rs                            |   4 +-
 strolle/src/light.rs                          |   9 +-
 strolle/src/material.rs                       |   9 +-
 strolle/src/mesh_triangle.rs                  |  21 +--
 strolle/src/triangle.rs                       |  22 ++--
 strolle/src/utils.rs                          |   4 +
 strolle/src/utils/bounding_box.rs             |   2 +-
 strolle/src/utils/interface.rs                |  58 +++++++++
 78 files changed, 745 insertions(+), 518 deletions(-)
 create mode 100644 strolle/src/utils/interface.rs

diff --git a/.gitignore b/.gitignore
index b555a1d6..f6433629 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ target
 /bevy-strolle/assets/demo
 /bevy-strolle/examples/bench-*
 /bevy-strolle/examples/scene*
+/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
index bc2d7549..5943300c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,3 @@ members = [
     "strolle-shaders",
 ]
 
-[patch."crates-io"]
-# TODO https://github.com/gfx-rs/naga/issues/2373
-naga = { git = "https://github.com/Patryk27/naga", branch = "v0.13.0-strolle" }
diff --git a/bevy-strolle/Cargo.toml b/bevy-strolle/Cargo.toml
index 683388d2..5805823a 100644
--- a/bevy-strolle/Cargo.toml
+++ b/bevy-strolle/Cargo.toml
@@ -4,16 +4,20 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.12.1" # TODO use default-features = false
-bevy_egui = "0.24"
+bevy = { version = "0.14.2", default-features = false, features = ["default"] }
+bevy_egui = { version = "0.29.0" }
+spirv-std = { git = "https://github.com/glasspangolin/rust-gpu.git" }
 log = "0.4.18"
 strolle = { path = "../strolle", features = ["metrics"] }
-wgpu = "0.17.2"
+wgpu = "0.20.1"
 
 [dev-dependencies]
-bevy = { version = "0.12.1", features = ["jpeg"] }
-bevy_mod_raycast = "0.16.0"
-bevy_rapier3d = "0.23.0"
-lazy_static = "1.4.0"
-smooth-bevy-cameras = "0.10.0"
-zip = { version = "0.6.6", default-features = false, features = ["deflate"] }
+bevy = { version = "0.14.2", default-features = false, features = ["default", "jpeg"] }
+bevy_mod_raycast = { version = "0.18.0" }
+smooth-bevy-cameras = { version = "0.12.0"}
+lazy_static = "1.5.0"
+zip = { version = "2.2.0", default-features = false, features = ["deflate"] }
+
+[patch.crates-io]
+bevy = { version = "0.14.2" }
+bevy_render = {version = "0.14.2"}
\ No newline at end of file
diff --git a/bevy-strolle/examples/_common.rs b/bevy-strolle/examples/_common.rs
index 6e0a9f82..f49b4d17 100644
--- a/bevy-strolle/examples/_common.rs
+++ b/bevy-strolle/examples/_common.rs
@@ -7,13 +7,14 @@ use std::env;
 use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
-
+use bevy::core_pipeline::core_3d::graph::Core3d;
 use bevy::prelude::*;
 use bevy::render::camera::CameraRenderGraph;
 use bevy::window::{CursorGrabMode, PrimaryWindow};
 use bevy_strolle::prelude::*;
 use smooth_bevy_cameras::controllers::fps::FpsCameraController;
 use zip::ZipArchive;
+use bevy_strolle::graph::StrolleGraph;
 
 pub fn extract_assets() {
     extract_asset("cornell");
@@ -48,7 +49,7 @@ fn extract_asset(name: &str) {
 // -----------------------------------------------------------------------------
 
 pub fn handle_camera(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<ButtonInput<KeyCode>>,
     mut window: Query<&mut Window, With<PrimaryWindow>>,
     mut camera: Query<(
         &Transform,
@@ -64,8 +65,8 @@ pub fn handle_camera(
         mut fps_camera_controller,
     ) = camera.single_mut();
 
-    if keys.just_pressed(KeyCode::Key1) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit1) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = match camera.mode {
             st::CameraMode::Image { denoise } => {
@@ -75,8 +76,8 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::Key2) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit2) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = match camera.mode {
             st::CameraMode::DiDiffuse { denoise } => {
@@ -86,8 +87,8 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::Key3) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit3) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = match camera.mode {
             st::CameraMode::DiSpecular { denoise } => {
@@ -97,8 +98,8 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::Key4) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit4) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = match camera.mode {
             st::CameraMode::GiDiffuse { denoise } => {
@@ -108,8 +109,8 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::Key5) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit5) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = match camera.mode {
             st::CameraMode::GiSpecular { denoise } => {
@@ -119,20 +120,20 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::Key8) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit8) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = st::CameraMode::BvhHeatmap;
     }
 
-    if keys.just_pressed(KeyCode::Key9) {
-        camera_render_graph.set(bevy_strolle::graph::NAME);
+    if keys.just_pressed(KeyCode::Digit9) {
+        camera_render_graph.set(StrolleGraph);
 
         camera.mode = st::CameraMode::Reference { depth: 1 };
     }
 
-    if keys.just_pressed(KeyCode::Key0) {
-        camera_render_graph.set("core_3d");
+    if keys.just_pressed(KeyCode::Digit0) {
+        camera_render_graph.set(Core3d);
     }
 
     if keys.just_pressed(KeyCode::Semicolon) {
@@ -149,7 +150,7 @@ pub fn handle_camera(
         };
     }
 
-    if keys.just_pressed(KeyCode::X) {
+    if keys.just_pressed(KeyCode::KeyX) {
         println!("{:?}", camera_xform.translation);
     }
 }
@@ -173,20 +174,20 @@ impl Default for Sun {
     }
 }
 
-pub fn handle_sun(keys: Res<Input<KeyCode>>, mut sun: ResMut<Sun>) {
-    if keys.just_pressed(KeyCode::H) {
+pub fn handle_sun(keys: Res<ButtonInput<KeyCode>>, mut sun: ResMut<Sun>) {
+    if keys.just_pressed(KeyCode::KeyH) {
         sun.azimuth -= 0.05;
     }
 
-    if keys.just_pressed(KeyCode::J) {
+    if keys.just_pressed(KeyCode::KeyJ) {
         sun.altitude -= 0.05;
     }
 
-    if keys.just_pressed(KeyCode::K) {
+    if keys.just_pressed(KeyCode::KeyK) {
         sun.altitude += 0.05;
     }
 
-    if keys.just_pressed(KeyCode::L) {
+    if keys.just_pressed(KeyCode::KeyL) {
         sun.azimuth += 0.05;
     }
 }
diff --git a/bevy-strolle/examples/cornell.rs b/bevy-strolle/examples/cornell.rs
index 637665d4..bf2dfb3e 100644
--- a/bevy-strolle/examples/cornell.rs
+++ b/bevy-strolle/examples/cornell.rs
@@ -6,6 +6,7 @@ use bevy::math::vec3;
 use bevy::prelude::*;
 use bevy::render::camera::CameraRenderGraph;
 use bevy::window::WindowResolution;
+use bevy_strolle::graph::StrolleGraph;
 use bevy_strolle::prelude::*;
 use smooth_bevy_cameras::controllers::orbit::{
     OrbitCameraBundle, OrbitCameraController, OrbitCameraPlugin,
@@ -56,14 +57,14 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
     commands
         .spawn(Camera3dBundle {
             camera_render_graph: CameraRenderGraph::new(
-                bevy_strolle::graph::NAME,
+                StrolleGraph,
             ),
             camera: Camera {
                 hdr: true,
                 ..default()
             },
             ..default()
-        })
+        }).insert(StrolleCamera::default())
         .insert(OrbitCameraBundle::new(
             {
                 OrbitCameraController {
diff --git a/bevy-strolle/examples/demo.rs b/bevy-strolle/examples/demo.rs
index 5e71fa01..47d31c38 100644
--- a/bevy-strolle/examples/demo.rs
+++ b/bevy-strolle/examples/demo.rs
@@ -2,12 +2,14 @@
 mod common;
 
 use std::f32::consts::PI;
-
-use bevy::core_pipeline::clear_color::ClearColorConfig;
+use bevy::asset::AssetContainer;
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::math::{uvec2, vec3};
 use bevy::prelude::*;
 use bevy::render::camera::{CameraRenderGraph, RenderTarget};
+use bevy::render::renderer::RenderDevice;
+use bevy::render::RenderPlugin;
+use bevy::render::settings::{RenderCreation, WgpuSettings};
 use bevy::render::texture::ImageSampler;
 use bevy::window::{CursorGrabMode, PrimaryWindow, WindowResolution};
 use bevy_strolle::prelude::*;
@@ -15,10 +17,8 @@ use smooth_bevy_cameras::controllers::fps::{
     FpsCameraBundle, FpsCameraController, FpsCameraPlugin,
 };
 use smooth_bevy_cameras::LookTransformPlugin;
-use wgpu::{
-    Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
-};
-
+use wgpu::{Extent3d, Limits, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages};
+use bevy_strolle::graph::StrolleGraph;
 use self::common::Sun;
 
 const VIEWPORT_SIZE: UVec2 = uvec2(640, 480);
@@ -48,6 +48,7 @@ fn main() {
         .add_systems(Startup, setup_window)
         .add_systems(Startup, setup_camera)
         .add_systems(Startup, setup_scene)
+        .add_systems(Startup, check_gpu_limits)
         .add_systems(Update, adjust_materials)
         .add_systems(Update, handle_materials)
         .add_systems(Update, common::handle_camera)
@@ -60,6 +61,21 @@ fn main() {
         .run();
 }
 
+fn check_gpu_limits(render_device: Res<RenderDevice>) {
+    let limits = render_device.limits();
+    info!("GPU Limits:");
+    info!("  max_color_attachment_bytes_per_sample: {}",
+          limits.max_color_attachment_bytes_per_sample);
+    info!("  max_texture_dimension_2d: {}",
+          limits.max_texture_dimension_2d);
+    info!("  max_storage_buffer_binding_size: {}",
+          limits.max_storage_buffer_binding_size);
+    info!("  max_bind_groups: {}",
+          limits.max_bind_groups);
+    info!("  max_bindings_per_bind_group: {}",
+          limits.max_bindings_per_bind_group);
+}
+
 fn setup_window(mut window: Query<&mut Window, With<PrimaryWindow>>) {
     let mut window = window.single_mut();
 
@@ -118,16 +134,13 @@ fn setup_camera(
             order: 1,
             ..default()
         },
-        camera_2d: Camera2d {
-            clear_color: ClearColorConfig::None,
-        },
+        camera_2d: Camera2d {},
         ..default()
     });
 
-    commands
-        .spawn(Camera3dBundle {
+    commands.spawn(Camera3dBundle {
             camera_render_graph: CameraRenderGraph::new(
-                bevy_strolle::graph::NAME,
+                StrolleGraph,
             ),
             camera: Camera {
                 order: 0,
@@ -136,8 +149,7 @@ fn setup_camera(
                 ..default()
             },
             ..default()
-        })
-        .insert(StrolleCamera::default())
+        }).insert(StrolleCamera::default())
         .insert(FpsCameraBundle::new(
             {
                 FpsCameraController {
@@ -181,7 +193,7 @@ fn setup_scene(
                 color: Color::WHITE,
                 range: 35.0,
                 radius: 0.15,
-                intensity: 5000.0,
+                intensity: 1000.0,
                 shadows_enabled: true,
                 ..default()
             },
@@ -203,10 +215,10 @@ fn setup_scene(
 
         commands
             .spawn(MaterialMeshBundle {
-                mesh: meshes.add(Mesh::from(shape::Torus::default())),
+                mesh: meshes.add(Mesh::from(Torus::default())),
                 material: materials.add(StandardMaterial {
                     base_color: color,
-                    emissive: color * 10.0,
+                    emissive: color.to_linear(),
                     ..default()
                 }),
                 transform: Transform::from_translation(torus)
@@ -214,7 +226,7 @@ fn setup_scene(
                     .with_scale(Vec3::splat(0.5)),
                 ..default()
             })
-            .insert(Torus);
+            .insert(StrTorus);
     }
 
     // ---
@@ -261,16 +273,16 @@ fn adjust_materials(
 }
 
 fn handle_materials(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<ButtonInput<KeyCode>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    if keys.just_pressed(KeyCode::T) {
+    if keys.just_pressed(KeyCode::KeyT) {
         for (_, material) in materials.iter_mut() {
             material.base_color_texture = None;
         }
     }
 
-    if keys.just_pressed(KeyCode::M) {
+    if keys.just_pressed(KeyCode::KeyM) {
         for (_, material) in materials.iter_mut() {
             if material.metallic == 0.0 {
                 material.metallic = 1.0;
@@ -291,13 +303,13 @@ struct Flashlight {
 }
 
 fn handle_flashlight(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<ButtonInput<KeyCode>>,
     mut flashlight: Query<(&mut Flashlight, &mut SpotLight)>,
     mut lights: Query<&mut PointLight>,
 ) {
     let (mut flashlight, mut flashlight_spot) = flashlight.single_mut();
 
-    if keys.just_pressed(KeyCode::F) {
+    if keys.just_pressed(KeyCode::KeyF) {
         flashlight.enabled = !flashlight.enabled;
 
         if flashlight.enabled {
@@ -330,11 +342,11 @@ fn animate_flashlight(
 // -----------------------------------------------------------------------------
 
 #[derive(Component)]
-struct Torus;
+struct StrTorus;
 
 fn animate_toruses(
     time: Res<Time>,
-    mut toruses: Query<&mut Transform, (With<Torus>, Without<Flashlight>)>,
+    mut toruses: Query<&mut Transform, (With<StrTorus>, Without<Flashlight>)>,
 ) {
     for mut xform in toruses.iter_mut() {
         xform.rotation = Quat::from_rotation_z(time.elapsed_seconds())
diff --git a/bevy-strolle/src/debug.rs b/bevy-strolle/src/debug.rs
index 77af56bf..36e881e6 100644
--- a/bevy-strolle/src/debug.rs
+++ b/bevy-strolle/src/debug.rs
@@ -2,6 +2,7 @@ use bevy::core_pipeline::fxaa;
 use bevy::core_pipeline::tonemapping::Tonemapping;
 use bevy::prelude::*;
 use bevy_egui::{egui, EguiContexts, EguiPlugin};
+use crate::utils::color_to_vec4;
 
 pub struct StrolleDebugPlugin;
 
@@ -89,7 +90,7 @@ fn draw_materials(
                     return;
                 };
 
-                let rgba = material.base_color.as_rgba_f32();
+                let rgba = color_to_vec4(material.base_color);
                 let mut rgb = [rgba[0], rgba[1], rgba[2]];
 
                 ui.color_edit_button_rgb(&mut rgb);
diff --git a/bevy-strolle/src/graph.rs b/bevy-strolle/src/graph.rs
index e2bd1d39..112c5c47 100644
--- a/bevy-strolle/src/graph.rs
+++ b/bevy-strolle/src/graph.rs
@@ -1,43 +1,45 @@
-pub const NAME: &str = "strolle";
-
-pub mod node {
-    pub const RENDERING: &str = "strolle_rendering";
-    pub const TONEMAPPING: &str = "strolle_tonemapping";
-    pub const FXAA: &str = "strolle_fxaa";
-    pub const UPSCALING: &str = "strolle_upscaling";
-}
-
 use bevy::core_pipeline::fxaa::FxaaNode;
 use bevy::core_pipeline::tonemapping::TonemappingNode;
 use bevy::core_pipeline::upscaling::UpscalingNode;
 use bevy::prelude::*;
-use bevy::render::render_graph::{RenderGraphApp, ViewNodeRunner};
-
+use bevy::render::render_graph::{RenderGraphApp, RenderSubGraph, ViewNodeRunner};
+use crate::prelude::RenderLabel;
 use crate::RenderingNode;
 
-pub(crate) fn setup(render_app: &mut App) {
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderSubGraph)]
+pub struct StrolleGraph;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+pub enum StrolleNode {
+    RENDERING,
+    TONEMAPPING,
+    FXAA,
+    UPSCALING
+}
+
+pub fn setup(render_app: &mut SubApp) {
     render_app
-        .add_render_sub_graph(NAME)
+        .add_render_sub_graph(StrolleGraph)
         .add_render_graph_node::<ViewNodeRunner<RenderingNode>>(
-            NAME,
-            node::RENDERING,
+            StrolleGraph,
+            StrolleNode::RENDERING,
         )
         .add_render_graph_node::<ViewNodeRunner<TonemappingNode>>(
-            NAME,
-            node::TONEMAPPING,
+            StrolleGraph,
+            StrolleNode::TONEMAPPING,
         )
         .add_render_graph_node::<ViewNodeRunner<UpscalingNode>>(
-            NAME,
-            node::UPSCALING,
+            StrolleGraph,
+            StrolleNode::UPSCALING,
         )
-        .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(NAME, node::FXAA)
+        .add_render_graph_node::<ViewNodeRunner<FxaaNode>>(StrolleGraph, StrolleNode::FXAA)
         .add_render_graph_edges(
-            NAME,
-            &[
-                node::RENDERING,
-                node::FXAA,
-                node::TONEMAPPING,
-                node::UPSCALING,
-            ],
+            StrolleGraph, (
+                StrolleNode::RENDERING,
+                StrolleNode::FXAA,
+                StrolleNode::TONEMAPPING,
+                StrolleNode::UPSCALING,
+            ),
         );
 }
diff --git a/bevy-strolle/src/lib.rs b/bevy-strolle/src/lib.rs
index 0c61bb8f..f6ab77d1 100644
--- a/bevy-strolle/src/lib.rs
+++ b/bevy-strolle/src/lib.rs
@@ -15,6 +15,7 @@ pub mod prelude {
 use std::ops;
 
 use bevy::prelude::*;
+use bevy::render::render_graph::RenderLabel;
 use bevy::render::render_resource::Texture;
 use bevy::render::renderer::RenderDevice;
 use bevy::render::RenderApp;
@@ -29,12 +30,14 @@ pub use self::sun::*;
 
 pub struct StrollePlugin;
 
+
+
 impl Plugin for StrollePlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<StrolleEvent>();
         app.insert_resource(StrolleSun::default());
 
-        if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app.insert_resource(SyncedState::default());
 
             stages::setup(render_app);
@@ -43,11 +46,11 @@ impl Plugin for StrollePlugin {
     }
 
     fn finish(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
 
-        let render_device = render_app.world.resource::<RenderDevice>();
+        let render_device = render_app.world().resource::<RenderDevice>();
         let engine = st::Engine::new(render_device.wgpu_device());
 
         render_app.insert_resource(EngineResource(engine));
diff --git a/bevy-strolle/src/rendering_node.rs b/bevy-strolle/src/rendering_node.rs
index e98a6704..169e6eb9 100644
--- a/bevy-strolle/src/rendering_node.rs
+++ b/bevy-strolle/src/rendering_node.rs
@@ -23,9 +23,12 @@ impl ViewNode for RenderingNode {
         let state = world.resource::<SyncedState>();
 
         let Some(camera) = state.cameras.get(&entity) else {
+            println!("No camera");
             return Ok(());
         };
 
+        //println!("Starting render for camera {:?}", entity);
+
         engine.render_camera(
             camera.handle,
             render_context.command_encoder(),
diff --git a/bevy-strolle/src/stages.rs b/bevy-strolle/src/stages.rs
index 73354035..791c06f0 100644
--- a/bevy-strolle/src/stages.rs
+++ b/bevy-strolle/src/stages.rs
@@ -4,7 +4,7 @@ mod prepare;
 use bevy::prelude::*;
 use bevy::render::{Render, RenderSet};
 
-pub(crate) fn setup(render_app: &mut App) {
+pub fn setup(render_app: &mut SubApp) {
     render_app.add_systems(
         ExtractSchedule,
         extract::meshes.in_set(RenderSet::ExtractCommands),
@@ -58,6 +58,5 @@ pub(crate) fn setup(render_app: &mut App) {
     render_app.add_systems(Render, prepare::sun.in_set(RenderSet::Prepare));
     render_app.add_systems(Render, prepare::cameras.in_set(RenderSet::Prepare));
 
-    render_app
-        .add_systems(Render, prepare::flush.in_set(RenderSet::PrepareFlush));
+    render_app.add_systems(Render, prepare::flush.in_set(RenderSet::PrepareResourcesFlush));
 }
diff --git a/bevy-strolle/src/stages/extract.rs b/bevy-strolle/src/stages/extract.rs
index 47f8e946..31bede67 100644
--- a/bevy-strolle/src/stages/extract.rs
+++ b/bevy-strolle/src/stages/extract.rs
@@ -33,9 +33,8 @@ pub(crate) fn meshes(
             AssetEvent::Removed { id } => {
                 removed.push(*id);
             }
-            AssetEvent::LoadedWithDependencies { .. } => {
-                //
-            }
+            AssetEvent::Unused { .. } => {}
+            AssetEvent::LoadedWithDependencies { .. } => {}
         }
     }
 
@@ -76,6 +75,7 @@ pub(crate) fn materials(
             AssetEvent::LoadedWithDependencies { .. } => {
                 //
             }
+            AssetEvent::Unused { .. } => {}
         }
     }
 
@@ -130,6 +130,7 @@ pub(crate) fn images(
             AssetEvent::LoadedWithDependencies { .. } => {
                 //
             }
+            AssetEvent::Unused { .. } => {}
         }
     }
 
@@ -235,7 +236,7 @@ pub(crate) fn instances(
                 //      should probably propagate the layers up to the BVH
                 //      leaves and adjust the raytracer to read those
                 if let Some(layers) = layers {
-                    if *layers != RenderLayers::all() {
+                    if *layers != RenderLayers::layer(0) {
                         // TODO inefficient; we should push only if the object
                         //      was visible before
                         removed.push(handle);
@@ -337,36 +338,21 @@ pub(crate) fn lights(
 #[allow(clippy::type_complexity)]
 pub(crate) fn cameras(
     mut commands: Commands,
-    cameras: Extract<
-        Query<(
-            Entity,
-            &Camera,
-            &CameraRenderGraph,
-            &Projection,
-            &GlobalTransform,
-            Option<&StrolleCamera>,
-        )>,
-    >,
+    cameras: Extract<Query<(
+        Entity,
+        &Camera,
+        &GlobalTransform,
+        &StrolleCamera,
+    )>>,
 ) {
-    for (
-        entity,
-        camera,
-        camera_render_graph,
-        projection,
-        transform,
-        strolle_camera,
-    ) in cameras.iter()
-    {
-        if !camera.is_active || **camera_render_graph != crate::graph::NAME {
-            continue;
-        }
+
+    for (entity, camera, transform, strolle_camera) in cameras.iter() {
 
         assert!(camera.hdr, "Strolle requires an HDR camera");
 
         commands.get_or_spawn(entity).insert(ExtractedCamera {
             transform: transform.compute_matrix(),
-            projection: projection.get_projection_matrix(),
-            mode: strolle_camera.map(|camera| camera.mode),
+            mode: Some(strolle_camera.mode),
         });
     }
 }
diff --git a/bevy-strolle/src/stages/prepare.rs b/bevy-strolle/src/stages/prepare.rs
index e0373372..f26008f9 100644
--- a/bevy-strolle/src/stages/prepare.rs
+++ b/bevy-strolle/src/stages/prepare.rs
@@ -3,23 +3,26 @@ use std::mem;
 use bevy::prelude::*;
 use bevy::render::camera::ExtractedCamera as BevyExtractedCamera;
 use bevy::render::mesh::VertexAttributeValues;
-use bevy::render::render_asset::RenderAssets;
+use bevy::render::render_asset::{RenderAssetUsages, RenderAssets};
 use bevy::render::render_resource::PrimitiveTopology;
 use bevy::render::renderer::{RenderDevice, RenderQueue};
+use bevy::render::texture::GpuImage;
 use bevy::render::view::ViewTarget;
 use bevy::utils::hashbrown::hash_map::Entry;
 use bevy::utils::HashSet;
 use strolle as st;
 
+use strolle::{ImageData, ToGpu};
+
 use crate::state::{
     ExtractedCamera, ExtractedImageData, ExtractedImages, ExtractedInstances,
     ExtractedLights, ExtractedMaterials, ExtractedMeshes, ExtractedSun,
     SyncedCamera, SyncedState,
 };
 use crate::utils::color_to_vec4;
-use crate::EngineResource;
+use crate::{EngineParams, EngineResource};
 
-pub(crate) fn meshes(
+pub fn meshes(
     mut engine: ResMut<EngineResource>,
     mut meshes: ResMut<ExtractedMeshes>,
 ) {
@@ -110,10 +113,10 @@ pub(crate) fn meshes(
                 let tan2 = mesh_tans.get(vs[2]).copied().unwrap_or_default();
 
                 st::MeshTriangle::default()
-                    .with_positions([position0, position1, position2])
-                    .with_normals([normal0, normal1, normal2])
-                    .with_uvs([uv0, uv1, uv2])
-                    .with_tangents([tan0, tan1, tan2])
+                    .with_positions([Vec3::from(position0), Vec3::from(position1), Vec3::from(position2)])
+                    .with_normals([Vec3::from(normal0), Vec3::from(normal1), Vec3::from(normal2)])
+                    .with_uvs([Vec2::from(uv0), Vec2::from(uv1), Vec2::from(uv2)])
+                    .with_tangents([Vec4::from(tan0), Vec4::from(tan1), Vec4::from(tan2)])
             })
             .collect();
 
@@ -121,7 +124,7 @@ pub(crate) fn meshes(
     }
 }
 
-pub(crate) fn materials(
+pub fn materials(
     mut engine: ResMut<EngineResource>,
     mut materials: ResMut<ExtractedMaterials>,
 ) {
@@ -154,11 +157,11 @@ pub(crate) fn materials(
         };
 
         st::Material {
-            base_color,
+            base_color: base_color.to_gpu(),
             base_color_texture: mat
                 .base_color_texture
                 .map(|handle| handle.id()),
-            emissive: color_to_vec4(mat.emissive),
+            emissive: color_to_vec4(Color::LinearRgba(mat.emissive)).to_gpu(),
             emissive_texture: mat.emissive_texture.map(|handle| handle.id()),
             perceptual_roughness: mat.perceptual_roughness,
             metallic: mat.metallic,
@@ -179,9 +182,9 @@ pub(crate) fn materials(
     }
 }
 
-pub(crate) fn images(
+pub fn images(
     mut engine: ResMut<EngineResource>,
-    textures: Res<RenderAssets<Image>>,
+    textures: Res<RenderAssets<GpuImage>>,
     mut images: ResMut<ExtractedImages>,
 ) {
     for handle in &images.removed {
@@ -197,12 +200,13 @@ pub(crate) fn images(
             ExtractedImageData::Raw { data } => st::ImageData::Raw { data },
 
             ExtractedImageData::Texture { is_dynamic } => {
+                let Some(gpu_image) = textures.get(entry.handle) else {
+                    warn!("Missing GPU image for handle {:?}", entry.handle);
+                    continue;
+                };
+
                 st::ImageData::Texture {
-                    texture: textures
-                        .get(entry.handle)
-                        .unwrap()
-                        .texture
-                        .clone(),
+                    texture: gpu_image.texture.clone(),
                     is_dynamic,
                 }
             }
@@ -230,7 +234,7 @@ pub(crate) fn images(
     }
 }
 
-pub(crate) fn instances(
+pub fn instances(
     mut engine: ResMut<EngineResource>,
     mut instances: ResMut<ExtractedInstances>,
 ) {
@@ -250,7 +254,7 @@ pub(crate) fn instances(
     }
 }
 
-pub(crate) fn lights(
+pub fn lights(
     mut engine: ResMut<EngineResource>,
     mut lights: ResMut<ExtractedLights>,
 ) {
@@ -263,7 +267,7 @@ pub(crate) fn lights(
     }
 }
 
-pub(crate) fn sun(
+pub fn sun(
     mut engine: ResMut<EngineResource>,
     mut sun: ResMut<ExtractedSun>,
 ) {
@@ -272,7 +276,7 @@ pub(crate) fn sun(
     }
 }
 
-pub(crate) fn cameras(
+pub fn cameras(
     device: Res<RenderDevice>,
     mut state: ResMut<SyncedState>,
     mut engine: ResMut<EngineResource>,
@@ -290,31 +294,36 @@ pub(crate) fn cameras(
 
     for (entity, view_target, bevy_ext_camera, ext_camera) in cameras.iter_mut()
     {
-        let camera = st::Camera {
-            mode: ext_camera.mode.unwrap_or_default(),
+        let format = view_target.main_texture_format();
 
-            viewport: {
-                let format = view_target.main_texture_format();
+        let Some(size) = bevy_ext_camera.physical_viewport_size else {
+            continue;
+        };
 
-                let Some(size) = bevy_ext_camera.physical_viewport_size else {
-                    continue;
-                };
+        let position = bevy_ext_camera
+            .viewport
+            .as_ref()
+            .map(|v| v.physical_position)
+            .unwrap_or_default();
+
+        let fov_y = std::f32::consts::FRAC_PI_4;
+        let aspect_ratio = size.x as f32 / size.y as f32;
+        let near_plane = 0.3;
+        let far_plane = 100.0;
 
-                let position = bevy_ext_camera
-                    .viewport
-                    .as_ref()
-                    .map(|v| v.physical_position)
-                    .unwrap_or_default();
+        let projection = Mat4::perspective_rh(fov_y, aspect_ratio, far_plane, near_plane);
 
+        let camera = st::Camera {
+            mode: ext_camera.mode.unwrap_or_default(),
+            viewport: {
                 st::CameraViewport {
                     format,
                     size,
                     position,
                 }
             },
-
             transform: ext_camera.transform,
-            projection: ext_camera.projection,
+            projection: projection,
         };
 
         match state.cameras.entry(entity) {
diff --git a/bevy-strolle/src/state.rs b/bevy-strolle/src/state.rs
index 978c4ff8..88a9c3b3 100644
--- a/bevy-strolle/src/state.rs
+++ b/bevy-strolle/src/state.rs
@@ -106,7 +106,6 @@ pub(crate) struct ExtractedLight {
 #[derive(Debug, Component)]
 pub(crate) struct ExtractedCamera {
     pub transform: Mat4,
-    pub projection: Mat4,
     pub mode: Option<st::CameraMode>,
 }
 
diff --git a/bevy-strolle/src/utils.rs b/bevy-strolle/src/utils.rs
index 77e75299..16a8172d 100644
--- a/bevy-strolle/src/utils.rs
+++ b/bevy-strolle/src/utils.rs
@@ -1,14 +1,16 @@
-use bevy::math::{vec3, vec4};
+
 use bevy::prelude::*;
 
 pub fn color_to_vec3(color: Color) -> Vec3 {
-    let [r, g, b, _] = color.as_linear_rgba_f32();
+    let [r, g, b, _] = color.to_linear().to_f32_array();
 
-    vec3(r, g, b)
+    Vec3::new(r, g, b)
 }
 
 pub fn color_to_vec4(color: Color) -> Vec4 {
-    let [r, g, b, a] = color.as_linear_rgba_f32();
+    let [r, g, b, a] = color.to_linear().to_f32_array();
 
-    vec4(r, g, b, a)
+    Vec4::new(r, g, b, a)
 }
+
+
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 0146b98d..0425aad8 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2023-09-30"
-components = ["cargo", "rust-src", "rustc-dev", "llvm-tools-preview"]
+channel = "nightly-2024-04-24"
+components = ["rust-src", "rustc-dev", "llvm-tools"]
\ No newline at end of file
diff --git a/strolle-gpu/Cargo.toml b/strolle-gpu/Cargo.toml
index c11bd669..66d4cd5a 100644
--- a/strolle-gpu/Cargo.toml
+++ b/strolle-gpu/Cargo.toml
@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bytemuck = { version = "1.13.1", features = ["derive", "min_const_generics"] }
-glam = { version = "0.24", default-features = false, features = ["bytemuck"] }
-spirv-std = { git = "https://github.com/EmbarkStudios/rust-gpu" }
+bytemuck = { version = "1.19.0", features = ["derive", "min_const_generics"] }
+glam = { version = "0.29.1", default-features = false, features = ["bytemuck"] }
+spirv-std = { git = "https://github.com/glasspangolin/rust-gpu.git" }
 
 [dev-dependencies]
 approx = "0.5.1"
diff --git a/strolle-gpu/src/brdf.rs b/strolle-gpu/src/brdf.rs
index fe6e29c2..90cb84e4 100644
--- a/strolle-gpu/src/brdf.rs
+++ b/strolle-gpu/src/brdf.rs
@@ -4,7 +4,7 @@ use glam::{Vec3, Vec4Swizzles};
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{F32Ext, GBufferEntry, WhiteNoise};
+use crate::{safe_any_orthonormal_pair, safe_normalize, F32Ext, GBufferEntry, WhiteNoise};
 
 #[derive(Clone, Copy)]
 pub struct DiffuseBrdf {
@@ -52,7 +52,7 @@ impl SpecularBrdf {
 
         let a = gbuffer.clamped_roughness();
         let n = gbuffer.normal;
-        let h = (l + v).normalize();
+        let h = safe_normalize(l + v);
         let n_dot_l = n.dot(l).saturate();
         let n_dot_h = n.dot(h).saturate();
         let l_dot_h = l.dot(h).saturate();
@@ -88,10 +88,10 @@ impl SpecularBrdf {
         let a = gbuffer.clamped_roughness();
         let n = gbuffer.normal;
         let a2 = a.sqr();
-        let (b, t) = n.any_orthonormal_pair();
+        let (b, t) = safe_any_orthonormal_pair(n);
 
-        let cos_theta = 0.0f32.max((1.0 - r0) / ((a2 - 1.0) * r0 + 1.0)).sqrt();
-        let sin_theta = 0.0f32.max(1.0 - cos_theta * cos_theta).sqrt();
+        let cos_theta = 0.0f32.max((1.0 - r0) / ((a2 - 1.0) * r0 + 1.0)).max(crate::STROLLE_EPSILON).sqrt();
+        let sin_theta = 0.0f32.max(1.0 - cos_theta * cos_theta).max(crate::STROLLE_EPSILON).sqrt();
 
         let phi = r1 * PI * 2.0;
 
@@ -102,7 +102,7 @@ impl SpecularBrdf {
         let n_dot_h = n.dot(h).saturate();
         let h_dot_v = h.dot(v).saturate();
 
-        let dir = (2.0 * h_dot_v * h - v).normalize();
+        let dir = safe_normalize(2.0 * h_dot_v * h - v);
         let pdf = ggx_distribution(n_dot_h, a) * n_dot_h / (4.0 * h_dot_v);
 
         BrdfSample {
diff --git a/strolle-gpu/src/camera.rs b/strolle-gpu/src/camera.rs
index 3023cc9d..69af7283 100644
--- a/strolle-gpu/src/camera.rs
+++ b/strolle-gpu/src/camera.rs
@@ -81,15 +81,14 @@ impl Camera {
         let screen_size = self.screen.xy();
         let screen_pos = screen_pos.as_vec2() + vec2(0.5, 0.5);
 
-        let ndc = screen_pos * 2.0 / screen_size - Vec2::ONE;
+        let ndc = screen_pos * 2.0 / Vec2::new((screen_size.x).max(crate::STROLLE_EPSILON), (screen_size.y).max(crate::STROLLE_EPSILON)) - Vec2::ONE;
         let ndc = vec2(ndc.x, -ndc.y);
 
-        let far_plane =
-            self.ndc_to_world.project_point3(ndc.extend(f32::EPSILON));
+        let far_plane = self.ndc_to_world.project_point3(ndc.extend(crate::STROLLE_EPSILON));
 
         let near_plane = self.ndc_to_world.project_point3(ndc.extend(1.0));
 
-        Ray::new(near_plane, (far_plane - near_plane).normalize())
+        Ray::new(near_plane, crate::safe_normalize(far_plane - near_plane))
     }
 
     /// Returns camera's approximate origin, without taking into account the
diff --git a/strolle-gpu/src/gbuffer.rs b/strolle-gpu/src/gbuffer.rs
index 4760c0ec..ea839595 100644
--- a/strolle-gpu/src/gbuffer.rs
+++ b/strolle-gpu/src/gbuffer.rs
@@ -20,30 +20,27 @@ impl GBufferEntry {
         let depth = d0.x;
         let normal = Normal::decode(d0.yz());
 
-        let (metallic, roughness, reflectance) = {
-            let [metallic, roughness, reflectance, ..] =
-                d0.w.to_bits().to_bytes();
+        let packed = d0.w.to_bits();
+        let metallic_u = (packed >> 24) & 0xFF;
+        let roughness_u = (packed >> 16) & 0xFF;
+        let reflectance_u = (packed >> 8) & 0xFF;
+        let emissive_r_u = packed & 0xFF;
 
-            let metallic = metallic as f32 / 255.0;
-            let roughness = (roughness as f32 / 255.0).sqr();
-            let reflectance = reflectance as f32 / 255.0;
+        let metallic = metallic_u as f32 / 255.0;
+        let roughness = roughness_u as f32 / 255.0;
+        let reflectance = reflectance_u as f32 / 255.0;
+        let emissive_r = emissive_r_u as f32 / 255.0;
 
-            (metallic, roughness, reflectance)
-        };
+        let w_scaled = d1.w as u32;
+        let emissive_g_u = (w_scaled >> 8) & 0xFF;
+        let emissive_b_u = w_scaled & 0xFF;
 
-        let emissive = d1.xyz();
+        let emissive_g = emissive_g_u as f32 / 255.0;
+        let emissive_b = emissive_b_u as f32 / 255.0;
 
-        let base_color = {
-            let [x, y, z, w] = d1.w.to_bits().to_bytes();
+        let emissive = Vec3::new(emissive_r, emissive_g, emissive_b);
 
-            vec4(
-                x as f32 / 255.0,
-                y as f32 / 255.0,
-                z as f32 / 255.0,
-                w as f32 / 63.0,
-            )
-            .powf(2.2)
-        };
+        let base_color = vec4(d1.x, d1.y, d1.z, 1.0); // Assuming alpha is 1.0
 
         Self {
             base_color,
@@ -57,55 +54,43 @@ impl GBufferEntry {
     }
 
     pub fn pack(self) -> [Vec4; 2] {
+        // d0: Rgba32Float
         let d0 = {
-            let x = self.depth;
-            let Vec2 { x: y, y: z } = Normal::encode(self.normal);
-
-            let w = {
-                let metallic = self.metallic.clamp(0.0, 1.0) * 255.0;
-                let roughness = self.roughness.sqrt().clamp(0.0, 1.0) * 255.0;
-                let reflectance = self.reflectance.clamp(0.0, 1.0) * 255.0;
-
-                f32::from_bits(u32::from_bytes([
-                    metallic as u32,
-                    roughness as u32,
-                    reflectance as u32,
-                    1,
-                ]))
-            };
+            let x = self.depth; // f32
+            let Vec2 { x: y, y: z } = Normal::encode(self.normal); // Encoded normal components
+
+            // Pack metallic, roughness, reflectance, and emissive_r into a u32
+            let metallic_u = (self.metallic.clamp(0.0, 1.0) * 255.0).round() as u32;
+            let roughness_u = (self.roughness.clamp(0.0, 1.0) * 255.0).round() as u32;
+            let reflectance_u = (self.reflectance.clamp(0.0, 1.0) * 255.0).round() as u32;
+            let emissive_r_u = (self.emissive.x.clamp(0.0, 1.0) * 255.0).round() as u32;
+
+            let packed = (metallic_u << 24)
+                | (roughness_u << 16)
+                | (reflectance_u << 8)
+                | emissive_r_u;
+
+            let w = f32::from_bits(packed);
 
             vec4(x, y, z, w)
         };
 
+        // d1: Rgba16Float
         let d1 = {
-            // TODO doesn't need to use as much space
-            let x = self.emissive.x;
-            let y = self.emissive.y;
-            let z = self.emissive.z;
-
-            let w = {
-                let base_color = self
-                    .base_color
-                    .powf(1.0 / 2.2)
-                    .clamp(Vec4::ZERO, Vec4::ONE);
-
-                let base_color = (vec4(
-                    base_color.x * 255.0,
-                    base_color.y * 255.0,
-                    base_color.z * 255.0,
-                    base_color.w * 63.0,
-                ))
-                .as_uvec4();
-
-                f32::from_bits(u32::from_bytes([
-                    base_color.x,
-                    base_color.y,
-                    base_color.z,
-                    base_color.w,
-                ]))
-            };
+            let base_color = self.base_color.clamp(Vec4::ZERO, Vec4::ONE);
 
-            vec4(x, y, z, w)
+            let emissive_g_u = (self.emissive.y.clamp(0.0, 1.0) * 255.0).round() as u32;
+            let emissive_b_u = (self.emissive.z.clamp(0.0, 1.0) * 255.0).round() as u32;
+
+            let emissive_packed = (emissive_g_u << 8) | emissive_b_u;
+            let w = emissive_packed as f32;
+
+            vec4(
+                base_color.x,
+                base_color.y,
+                base_color.z,
+                w, // Store packed emissive_g and emissive_b
+            )
         };
 
         [d0, d1]
diff --git a/strolle-gpu/src/hit.rs b/strolle-gpu/src/hit.rs
index b961da51..211d3a99 100644
--- a/strolle-gpu/src/hit.rs
+++ b/strolle-gpu/src/hit.rs
@@ -84,7 +84,7 @@ pub struct TriangleHit {
 impl TriangleHit {
     pub fn none() -> Self {
         Self {
-            distance: f32::MAX,
+            distance: 1000_000f32,
             point: Default::default(),
             normal: Default::default(),
             uv: Default::default(),
@@ -120,7 +120,7 @@ impl TriangleHit {
     }
 
     pub fn is_some(self) -> bool {
-        self.distance < f32::MAX
+        self.distance < 1000_000f32
     }
 
     pub fn is_none(self) -> bool {
diff --git a/strolle-gpu/src/light.rs b/strolle-gpu/src/light.rs
index 38e195aa..3c1b6f5d 100644
--- a/strolle-gpu/src/light.rs
+++ b/strolle-gpu/src/light.rs
@@ -1,17 +1,17 @@
 use core::f32::consts::PI;
 use core::ops::Mul;
-
 use bytemuck::{Pod, Zeroable};
 use glam::{vec2, vec4, Vec2, Vec3, Vec4, Vec4Swizzles};
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
 use crate::{
-    DiffuseBrdf, F32Ext, Hit, Normal, Ray, SpecularBrdf, Vec3Ext, WhiteNoise,
+    safe_any_orthonormal_pair, safe_normalize,
+    DiffuseBrdf, F32Ext, Hit, Normal, Ray, SpecularBrdf, Vec3Ext, WhiteNoise
 };
 
 #[repr(C)]
-#[derive(Clone, Copy, Default, Pod, Zeroable)]
+#[derive(Clone, Copy, Pod, Zeroable)]
 #[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
 pub struct Light {
     /// x - position x
@@ -41,6 +41,21 @@ pub struct Light {
     pub prev_d2: Vec4,
 }
 
+impl Default for Light {
+    fn default() -> Self {
+        Self {
+            d0: Vec4::new(0.0, 0.0, 0.0, 1.0),  // Non-zero radius
+            d1: Vec4::new(0.0, 0.0, 0.0, 1.0),  // Non-zero range
+            d2: Vec4::ZERO,
+            d3: Vec4::ZERO,
+            prev_d0: Vec4::ZERO,
+            prev_d1: Vec4::ZERO,
+            prev_d2: Vec4::ZERO,
+        }
+    }
+}
+
+
 impl Light {
     pub const TYPE_NONE: u32 = 0;
     pub const TYPE_POINT: u32 = 1;
@@ -50,7 +65,7 @@ impl Light {
         Self {
             // TODO incorrect
             d0: position.extend(25.0),
-            d1: color.extend(f32::INFINITY),
+            d1: color.extend(1000_000f32),
             d2: vec4(
                 f32::from_bits(Self::TYPE_POINT),
                 Default::default(),
@@ -125,7 +140,7 @@ impl Light {
     }
 
     pub fn clear_slot(&mut self) {
-        self.d3.x = f32::from_bits(0);
+        self.d3.x = f32::from_bits(1);
     }
 
     pub fn commit(&mut self) {
@@ -152,7 +167,7 @@ impl Light {
             (1.0 - (angle / self.spot_angle()).powf(3.0)).saturate()
         };
 
-        let f_dist = if self.range() == f32::INFINITY {
+        let f_dist = if self.range() == 1000_000f32 {
             1.0
         } else {
             let l2 = l.length_squared();
@@ -216,23 +231,27 @@ impl Light {
 
     pub fn ray_bnoise(self, sample: Vec2, hit_point: Vec3) -> Ray {
         let to_light = self.center() - hit_point;
-        let light_dir = to_light.normalize();
         let light_distance = to_light.length();
-        let light_radius = self.radius() / light_distance;
-        let (light_tangent, light_bitangent) = light_dir.any_orthonormal_pair();
+
+        // Avoid potential division by zero or very small numbers
+        let safe_distance = light_distance.max(1.0);
+        let light_dir = to_light / safe_distance;
+
+        // Use clamped values for radius calculations
+        let safe_radius = self.radius().max(crate::STROLLE_EPSILON);
+        let light_radius = (safe_radius / safe_distance).min(10.0);
+
+        let (light_tangent, light_bitangent) = safe_any_orthonormal_pair(light_dir);
 
         let disk_point = {
             let angle = 2.0 * PI * sample.x;
-            let radius = sample.y.sqrt();
-
+            let radius = sample.y.max(crate::STROLLE_EPSILON).sqrt();
             vec2(angle.sin(), angle.cos()) * radius * light_radius
         };
 
-        let ray_dir = light_dir
+        let ray_dir = safe_normalize(light_dir
             + disk_point.x * light_tangent
-            + disk_point.y * light_bitangent;
-
-        let ray_dir = ray_dir.normalize();
+            + disk_point.y * light_bitangent);
 
         Ray::new(hit_point + ray_dir * light_distance, -ray_dir)
             .with_len(light_distance)
diff --git a/strolle-gpu/src/noise/white.rs b/strolle-gpu/src/noise/white.rs
index 9ddc9ec2..db2b1ed9 100644
--- a/strolle-gpu/src/noise/white.rs
+++ b/strolle-gpu/src/noise/white.rs
@@ -4,7 +4,7 @@ use glam::{vec2, vec3, UVec2, Vec2, Vec3};
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::F32Ext;
+use crate::{safe_any_orthonormal_pair, F32Ext};
 
 #[derive(Clone, Copy)]
 pub struct WhiteNoise {
@@ -74,9 +74,9 @@ impl WhiteNoise {
     /// Generates a uniform sample on a hemisphere around given normal.
     pub fn sample_hemisphere(&mut self, normal: Vec3) -> Vec3 {
         let cos_theta = self.sample();
-        let sin_theta = (1.0f32 - cos_theta.sqr()).sqrt();
+        let sin_theta = (1.0f32 - cos_theta.sqr()).max(0.0).sqrt();
         let phi = 2.0 * PI * self.sample();
-        let (t, b) = normal.any_orthonormal_pair();
+        let (t, b) = safe_any_orthonormal_pair(normal);
 
         (t * phi.cos() + b * phi.sin()) * sin_theta + normal * cos_theta
     }
diff --git a/strolle-gpu/src/ray.rs b/strolle-gpu/src/ray.rs
index da2a9ccf..81c559e8 100644
--- a/strolle-gpu/src/ray.rs
+++ b/strolle-gpu/src/ray.rs
@@ -21,12 +21,22 @@ pub struct Ray {
 
 impl Ray {
     pub fn new(origin: Vec3, dir: Vec3) -> Self {
-        Self {
-            origin,
-            dir,
-            inv_dir: 1.0 / dir,
-            len: f32::MAX,
+        if dir.length() > 0.01 {
+            Self {
+                origin,
+                dir,
+                inv_dir: 1.0 / dir,
+                len: 1000_000f32,
+            }
+        } else {
+            Self {
+                origin,
+                dir,
+                inv_dir: Vec3::ZERO,
+                len: 1000_000f32,
+            }
         }
+
     }
 
     pub fn with_len(mut self, len: f32) -> Self {
@@ -280,7 +290,7 @@ impl Ray {
         }
 
         let mut tmin = 0.0;
-        let mut tmax = f32::MAX;
+        let mut tmax = 1000_000f32;
 
         let t1 = (aabb_min - self.origin) * self.inv_dir;
         let t2 = (aabb_max - self.origin) * self.inv_dir;
@@ -297,7 +307,7 @@ impl Ray {
         if tmin <= tmax {
             tmin
         } else {
-            f32::MAX
+            1000_000f32
         }
     }
 
diff --git a/strolle-gpu/src/reservoir/di.rs b/strolle-gpu/src/reservoir/di.rs
index 111fabe3..af60725c 100644
--- a/strolle-gpu/src/reservoir/di.rs
+++ b/strolle-gpu/src/reservoir/di.rs
@@ -13,52 +13,55 @@ pub struct DiReservoir {
     pub reservoir: Reservoir<DiSample>,
 }
 
-impl DiReservoir {
-    pub fn read(buffer: &[Vec4], id: usize) -> Self {
-        let d0 = unsafe { *buffer.index_unchecked(2 * id) };
-        let d1 = unsafe { *buffer.index_unchecked(2 * id + 1) };
-        let [is_occluded, confidence, ..] = d0.w.to_bits().to_bytes();
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+pub struct DiReservoirData {
+    pub m: f32,
+    pub w: f32,
+    pub pdf: f32,
+    pub confidence: f32,
+    pub is_occluded: u32,
+    pub light_id: u32,
+    // Add padding to align `light_point` to 16 bytes
+    _padding0: [u32; 2],
+    pub light_point: Vec3
+}
 
+impl DiReservoir {
+    pub fn read(buffer: &[DiReservoirData], id: usize) -> Self {
+        let data = unsafe { *buffer.index_unchecked(id) };
         Self {
             reservoir: Reservoir {
                 sample: DiSample {
-                    pdf: d0.z,
-                    confidence: confidence as f32,
-                    light_id: LightId::new(d1.w.to_bits()),
-                    light_point: d1.xyz(),
-                    is_occluded: is_occluded > 0,
+                    pdf: data.pdf,
+                    confidence: data.confidence,
+                    light_id: LightId::new(data.light_id),
+                    light_point: data.light_point,
+                    is_occluded: data.is_occluded != 0,
                 },
-                m: d0.x,
-                w: d0.y,
+                m: data.m,
+                w: data.w,
             },
         }
     }
 
-    pub fn write(self, buffer: &mut [Vec4], id: usize) {
-        let d0 = vec4(
-            self.reservoir.m,
-            self.reservoir.w,
-            self.sample.pdf,
-            f32::from_bits(u32::from_bytes([
-                self.sample.is_occluded as u32,
-                self.sample.confidence as u32,
-                0,
-                0,
-            ])),
-        );
-
-        let d1 = self
-            .sample
-            .light_point
-            .extend(f32::from_bits(self.sample.light_id.get()));
-
+    pub fn write(self, buffer: &mut [DiReservoirData], id: usize) {
+        let data = DiReservoirData {
+            m: self.reservoir.m,
+            w: self.reservoir.w,
+            pdf: self.sample.pdf,
+            confidence: self.sample.confidence,
+            is_occluded: self.sample.is_occluded as u32,
+            light_id: self.sample.light_id.get(),
+            _padding0: [0u32; 2],
+            light_point: self.sample.light_point
+        };
         unsafe {
-            *buffer.index_unchecked_mut(2 * id) = d0;
-            *buffer.index_unchecked_mut(2 * id + 1) = d1;
+            *buffer.index_unchecked_mut(id) = data;
         }
     }
 
-    pub fn copy(input: &[Vec4], output: &mut [Vec4], id: usize) {
+    pub fn copy(input: &[DiReservoirData], output: &mut [DiReservoirData], id: usize) {
         // TODO optimize
         Self::read(input, id).write(output, id);
     }
@@ -119,7 +122,7 @@ impl DiSample {
     pub fn ray(self, hit_point: Vec3) -> Ray {
         let dir = hit_point - self.light_point;
 
-        Ray::new(self.light_point, dir.normalize()).with_len(dir.length())
+        Ray::new(self.light_point, crate::safe_normalize(dir)).with_len(dir.length())
     }
 }
 
@@ -147,7 +150,7 @@ mod tests {
             }
         }
 
-        let mut buffer = [Vec4::ZERO; 2 * 10];
+        let mut buffer = [DiReservoirData::default(), DiReservoirData::default()];
 
         for idx in 0..10 {
             target(idx).write(&mut buffer, idx);
diff --git a/strolle-gpu/src/surface.rs b/strolle-gpu/src/surface.rs
index 0df86b20..6768121f 100644
--- a/strolle-gpu/src/surface.rs
+++ b/strolle-gpu/src/surface.rs
@@ -1,4 +1,4 @@
-use glam::{UVec2, Vec3, Vec4Swizzles};
+use glam::{UVec2, Vec2, Vec3, Vec4Swizzles};
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
@@ -60,10 +60,19 @@ impl<'a> SurfaceMap<'a> {
     pub fn get(self, screen_pos: UVec2) -> Surface {
         let d0 = self.tex.read(screen_pos);
 
+        let depth = d0.x;
+        let normal = Normal::decode(Vec2::new(d0.y, d0.z));
+
+        let packed = d0.w.to_bits();
+        let roughness_u = (packed >> 16) & 0xFF;
+        let roughness = roughness_u as f32 / 255.0;
+
         Surface {
-            normal: Normal::decode(d0.xy()),
-            depth: d0.z,
-            roughness: d0.w,
+            normal: normal,
+            depth: depth,
+            roughness: roughness,
         }
     }
 }
+
+
diff --git a/strolle-gpu/src/triangle.rs b/strolle-gpu/src/triangle.rs
index bf52d5a5..f694c2ca 100644
--- a/strolle-gpu/src/triangle.rs
+++ b/strolle-gpu/src/triangle.rs
@@ -70,7 +70,7 @@ impl Triangle {
         let pvec = ray.dir().cross(v0v2);
         let det = v0v1.dot(pvec);
 
-        if det.abs() < f32::EPSILON {
+        if det.abs() < crate::STROLLE_EPSILON {
             return false;
         }
 
diff --git a/strolle-gpu/src/utils.rs b/strolle-gpu/src/utils.rs
index 36b6bdd8..0de4684a 100644
--- a/strolle-gpu/src/utils.rs
+++ b/strolle-gpu/src/utils.rs
@@ -6,7 +6,7 @@ mod vec3_ext;
 
 use core::ops;
 
-use glam::{uvec2, UVec2};
+use glam::{uvec2, UVec2, Vec3};
 use spirv_std::Image;
 
 pub use self::bilinear_filter::*;
@@ -41,3 +41,26 @@ pub fn resolve_checkerboard_alt(global_id: UVec2, frame: u32) -> UVec2 {
 pub fn got_checkerboard_at(screen_pos: UVec2, frame: u32) -> bool {
     screen_pos == resolve_checkerboard(screen_pos / uvec2(2, 1), frame)
 }
+
+pub fn safe_normalize(v: Vec3) -> Vec3 {
+    let len = v.length();
+    if len > 0.0 && len < 1_000_000.0 {
+        v / len
+    } else {
+        Vec3::ZERO
+    }
+}
+
+pub fn safe_any_orthonormal_pair(normal: Vec3) -> (Vec3, Vec3) {
+    // Choose a helper vector that is not parallel to the normal
+    let helper = if normal.x * normal.x > normal.z * normal.z {
+        Vec3::new(normal.y, -normal.x, 0.0)
+    } else {
+        Vec3::new(0.0, -normal.z, normal.y)
+    };
+    let tangent = safe_normalize(normal.cross(helper));
+    let bitangent = normal.cross(tangent);
+    (tangent, bitangent)
+}
+
+pub const STROLLE_EPSILON: f32 = 0.000_0001;
\ No newline at end of file
diff --git a/strolle-gpu/src/utils/f32_ext.rs b/strolle-gpu/src/utils/f32_ext.rs
index 9d989195..6ab0f6dc 100644
--- a/strolle-gpu/src/utils/f32_ext.rs
+++ b/strolle-gpu/src/utils/f32_ext.rs
@@ -21,7 +21,7 @@ impl F32Ext for f32 {
     }
 
     fn inverse_sqrt(self) -> Self {
-        1.0 / self.sqrt()
+        1.0 / self.max(crate::STROLLE_EPSILON).sqrt()
     }
 
     fn acos_approx(self) -> Self {
diff --git a/strolle-shader-builder/Cargo.toml b/strolle-shader-builder/Cargo.toml
index 46e34ed0..13f84289 100644
--- a/strolle-shader-builder/Cargo.toml
+++ b/strolle-shader-builder/Cargo.toml
@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-spirv-builder = { git = "https://github.com/EmbarkStudios/rust-gpu" }
+spirv-builder = { git = "https://github.com/glasspangolin/rust-gpu.git" }
diff --git a/strolle-shaders/Cargo.toml b/strolle-shaders/Cargo.toml
index b78e2dfb..61f193c6 100644
--- a/strolle-shaders/Cargo.toml
+++ b/strolle-shaders/Cargo.toml
@@ -11,4 +11,4 @@ crate-type = ["dylib"]
 strolle-gpu = { path = "../strolle-gpu" }
 
 # Crates.io
-spirv-std = { git = "https://github.com/EmbarkStudios/rust-gpu" }
+spirv-std = { git = "https://github.com/glasspangolin/rust-gpu.git" }
\ No newline at end of file
diff --git a/strolle-shaders/src/di_resolving.rs b/strolle-shaders/src/di_resolving.rs
index 6ae809cc..561b8c25 100644
--- a/strolle-shaders/src/di_resolving.rs
+++ b/strolle-shaders/src/di_resolving.rs
@@ -24,11 +24,11 @@ pub fn main(
     #[spirv(descriptor_set = 1, binding = 4)]
     atmosphere_sky_lut_sampler: &Sampler,
     #[spirv(descriptor_set = 1, binding = 5)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 6)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 6)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 7, storage_buffer)]
-    next_reservoirs: &[Vec4],
+    next_reservoirs: &[DiReservoirData],
     #[spirv(descriptor_set = 1, binding = 8, storage_buffer)]
-    prev_reservoirs: &mut [Vec4],
+    prev_reservoirs: &mut [DiReservoirData],
     #[spirv(descriptor_set = 1, binding = 9)] diff_output: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 10)] spec_output: TexRgba32,
 ) {
@@ -62,8 +62,9 @@ pub fn main(
     let mut res =
         DiReservoir::read(next_reservoirs, camera.screen_to_idx(screen_pos));
 
-    let confidence;
+    let confidence: f32;
     let radiance;
+    let metallic;
 
     if hit.is_some() {
         let is_occluded = res.sample.ray(hit.point).intersect(
@@ -79,7 +80,7 @@ pub fn main(
         confidence = if res.sample.is_occluded == is_occluded {
             res.sample.confidence
         } else {
-            0.0
+            0.01
         };
 
         res.sample.confidence = 1.0;
@@ -90,18 +91,24 @@ pub fn main(
         } else {
             lights.get(res.sample.light_id).radiance(hit) * res.w
         };
+
+        metallic = hit.gbuffer.metallic;
     } else {
         confidence = 1.0;
 
+        let dir = camera.ray(screen_pos).dir();
+
         radiance = LightRadiance {
-            radiance: atmosphere.sample(world.sun_dir(), hit.dir),
+            radiance: atmosphere.sample(world.sun_dir(), dir),
             diff_brdf: Vec3::ONE,
             spec_brdf: Vec3::ZERO,
         };
+
+        metallic = 0.0;
     };
 
     unsafe {
-        let diff_brdf = (1.0 - hit.gbuffer.metallic) / PI;
+        let diff_brdf = (1.0 - metallic) * (1.0 / PI);
         let spec_brdf = radiance.spec_brdf;
 
         diff_output.write(
diff --git a/strolle-shaders/src/di_sampling.rs b/strolle-shaders/src/di_sampling.rs
index 5351dd0a..1c5a2c94 100644
--- a/strolle-shaders/src/di_sampling.rs
+++ b/strolle-shaders/src/di_sampling.rs
@@ -19,9 +19,9 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 7, uniform)] world: &World,
     #[spirv(descriptor_set = 1, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 1, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 3, storage_buffer)]
-    out_reservoirs: &mut [Vec4],
+    out_reservoirs: &mut [DiReservoirData],
 ) {
     let screen_pos = global_id.xy();
     let screen_idx = camera.screen_to_idx(screen_pos);
diff --git a/strolle-shaders/src/di_spatial_resampling.rs b/strolle-shaders/src/di_spatial_resampling.rs
index b8696d1f..f5f16982 100644
--- a/strolle-shaders/src/di_spatial_resampling.rs
+++ b/strolle-shaders/src/di_spatial_resampling.rs
@@ -8,9 +8,9 @@ pub fn pick(
     lights: &[Light],
     #[spirv(descriptor_set = 1, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 1, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 3, storage_buffer)]
-    reservoirs: &[Vec4],
+    reservoirs: &[DiReservoirData],
     #[spirv(descriptor_set = 1, binding = 4)] buf_d0: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 5)] buf_d1: TexRgba32,
 ) {
@@ -214,9 +214,9 @@ pub fn sample(
     #[spirv(push_constant)] params: &PassParams,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1, storage_buffer)]
-    in_reservoirs: &[Vec4],
+    in_reservoirs: &[DiReservoirData],
     #[spirv(descriptor_set = 0, binding = 2, storage_buffer)]
-    out_reservoirs: &mut [Vec4],
+    out_reservoirs: &mut [DiReservoirData],
     #[spirv(descriptor_set = 0, binding = 3)] buf_d2: TexRgba32,
 ) {
     let global_id = global_id.xy();
diff --git a/strolle-shaders/src/di_temporal_resampling.rs b/strolle-shaders/src/di_temporal_resampling.rs
index 92fdbc02..fc7bce6a 100644
--- a/strolle-shaders/src/di_temporal_resampling.rs
+++ b/strolle-shaders/src/di_temporal_resampling.rs
@@ -10,13 +10,13 @@ pub fn main(
     #[spirv(descriptor_set = 1, binding = 1, uniform)] prev_camera: &Camera,
     #[spirv(descriptor_set = 1, binding = 2)] reprojection_map: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 3)] curr_prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 4)] curr_prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 4)] curr_prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 5)] prev_prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 6)] prev_prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 6)] prev_prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 7, storage_buffer)]
-    prev_reservoirs: &[Vec4],
+    prev_reservoirs: &[DiReservoirData],
     #[spirv(descriptor_set = 1, binding = 8, storage_buffer)]
-    curr_reservoirs: &mut [Vec4],
+    curr_reservoirs: &mut [DiReservoirData],
 ) {
     let lhs_pos = global_id.xy();
     let lhs_idx = curr_camera.screen_to_idx(lhs_pos);
diff --git a/strolle-shaders/src/frame_composition.rs b/strolle-shaders/src/frame_composition.rs
index 84507fe6..e746f00c 100644
--- a/strolle-shaders/src/frame_composition.rs
+++ b/strolle-shaders/src/frame_composition.rs
@@ -20,7 +20,7 @@ pub fn fs(
     #[spirv(frag_coord)] pos: Vec4,
     #[spirv(push_constant)] params: &FrameCompositionPassParams,
     #[spirv(descriptor_set = 0, binding = 0)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 2)] di_diff_colors: TexRgba32,
     #[spirv(descriptor_set = 0, binding = 3)] di_spec_colors: TexRgba32,
     #[spirv(descriptor_set = 0, binding = 4)] gi_diff_colors: TexRgba32,
diff --git a/strolle-shaders/src/frame_denoising.rs b/strolle-shaders/src/frame_denoising.rs
index be37711e..b6f16c40 100644
--- a/strolle-shaders/src/frame_denoising.rs
+++ b/strolle-shaders/src/frame_denoising.rs
@@ -4,7 +4,7 @@ use strolle_gpu::prelude::*;
 pub fn reproject(
     #[spirv(global_invocation_id)] global_id: UVec3,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
-    #[spirv(descriptor_set = 0, binding = 1)] prim_surface_map: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
     #[spirv(descriptor_set = 0, binding = 2)] reprojection_map: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 0)] prev_colors: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 1)] prev_moments: TexRgba32,
@@ -13,7 +13,7 @@ pub fn reproject(
     #[spirv(descriptor_set = 1, binding = 4)] moments: TexRgba32,
 ) {
     let screen_pos = global_id.xy();
-    let prim_surface_map = SurfaceMap::new(prim_surface_map);
+    let prim_surface_map = SurfaceMap::new(prim_gbuffer_d0);
     let reprojection_map = ReprojectionMap::new(reprojection_map);
 
     if !camera.contains(screen_pos) {
@@ -81,7 +81,7 @@ pub fn reproject(
 pub fn estimate_variance(
     #[spirv(global_invocation_id)] global_id: UVec3,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
-    #[spirv(descriptor_set = 0, binding = 1)] prim_surface_map: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 0)] di_colors: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 1)] di_moments: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 2)] di_output: TexRgba32,
@@ -90,7 +90,7 @@ pub fn estimate_variance(
     #[spirv(descriptor_set = 2, binding = 2)] gi_output: TexRgba32,
 ) {
     let screen_pos = global_id.xy();
-    let prim_surface_map = SurfaceMap::new(prim_surface_map);
+    let prim_surface_map = SurfaceMap::new(prim_gbuffer_d0);
 
     if !camera.contains(screen_pos) {
         return;
@@ -222,7 +222,7 @@ pub fn wavelet(
     #[spirv(push_constant)] params: &FrameDenoisingWaveletPassParams,
     #[spirv(descriptor_set = 0, binding = 0)] blue_noise_tex: TexRgba8,
     #[spirv(descriptor_set = 0, binding = 1, uniform)] camera: &Camera,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_surface_map: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d0: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 0)] di_input: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 1)] di_output: TexRgba32,
     #[spirv(descriptor_set = 2, binding = 0)] gi_input: TexRgba32,
@@ -230,7 +230,7 @@ pub fn wavelet(
 ) {
     let screen_pos = global_id.xy();
     let bnoise = BlueNoise::new(blue_noise_tex, screen_pos, params.frame);
-    let prim_surface_map = SurfaceMap::new(prim_surface_map);
+    let prim_surface_map = SurfaceMap::new(prim_gbuffer_d0);
 
     if !camera.contains(screen_pos) {
         return;
diff --git a/strolle-shaders/src/frame_reprojection.rs b/strolle-shaders/src/frame_reprojection.rs
index 4eecaf44..84e1b286 100644
--- a/strolle-shaders/src/frame_reprojection.rs
+++ b/strolle-shaders/src/frame_reprojection.rs
@@ -8,14 +8,14 @@ pub fn main(
     #[spirv(global_invocation_id)] global_id: UVec3,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1, uniform)] prev_camera: &Camera,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_surface_map: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 3)] prev_prim_surface_map: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 4)] velocity_map: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d0: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 3)] prev_prim_gbuffer_d0: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 4)] velocity_map: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 5)] reprojection_map: TexRgba32,
 ) {
     let screen_pos = global_id.xy();
-    let prim_surface_map = SurfaceMap::new(prim_surface_map);
-    let prev_prim_surface_map = SurfaceMap::new(prev_prim_surface_map);
+    let prim_surface_map = SurfaceMap::new(prim_gbuffer_d0);
+    let prev_prim_surface_map = SurfaceMap::new(prev_prim_gbuffer_d0);
     let reprojection_map = ReprojectionMap::new(reprojection_map);
 
     if !camera.contains(screen_pos) {
diff --git a/strolle-shaders/src/gi_preview_resampling.rs b/strolle-shaders/src/gi_preview_resampling.rs
index a5125d5d..74e3005c 100644
--- a/strolle-shaders/src/gi_preview_resampling.rs
+++ b/strolle-shaders/src/gi_preview_resampling.rs
@@ -6,19 +6,18 @@ pub fn main(
     #[spirv(push_constant)] params: &GiPreviewResamplingPass,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 3)] prim_surface_map: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 4, storage_buffer)]
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba16,
+    #[spirv(descriptor_set = 0, binding = 3, storage_buffer)]
     in_reservoirs_a: &[Vec4],
-    #[spirv(descriptor_set = 0, binding = 5, storage_buffer)]
+    #[spirv(descriptor_set = 0, binding = 4, storage_buffer)]
     in_reservoirs_b: &[Vec4],
-    #[spirv(descriptor_set = 0, binding = 6, storage_buffer)]
+    #[spirv(descriptor_set = 0, binding = 5, storage_buffer)]
     out_reservoirs: &mut [Vec4],
 ) {
     let center_pos = global_id.xy();
     let center_idx = camera.screen_to_idx(center_pos);
     let mut wnoise = WhiteNoise::new(params.seed, center_pos);
-    let prim_surface_map = SurfaceMap::new(prim_surface_map);
+    let prim_surface_map = SurfaceMap::new(prim_gbuffer_d0);
 
     if !camera.contains(center_pos) {
         return;
diff --git a/strolle-shaders/src/gi_reprojection.rs b/strolle-shaders/src/gi_reprojection.rs
index 999aa5f1..711b4a1a 100644
--- a/strolle-shaders/src/gi_reprojection.rs
+++ b/strolle-shaders/src/gi_reprojection.rs
@@ -5,7 +5,7 @@ pub fn main(
     #[spirv(global_invocation_id)] global_id: UVec3,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 3)] reprojection_map: TexRgba32,
     #[spirv(descriptor_set = 0, binding = 4, storage_buffer)]
     in_reservoirs: &[Vec4],
diff --git a/strolle-shaders/src/gi_resolving.rs b/strolle-shaders/src/gi_resolving.rs
index 63d678a8..62e14a37 100644
--- a/strolle-shaders/src/gi_resolving.rs
+++ b/strolle-shaders/src/gi_resolving.rs
@@ -6,7 +6,7 @@ pub fn main(
     #[spirv(push_constant)] params: &GiResolvingPassParams,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 3, storage_buffer)]
     in_reservoirs_a: &[Vec4],
     #[spirv(descriptor_set = 0, binding = 4, storage_buffer)]
diff --git a/strolle-shaders/src/gi_sampling_a.rs b/strolle-shaders/src/gi_sampling_a.rs
index 766b05f6..b0bc7d6c 100644
--- a/strolle-shaders/src/gi_sampling_a.rs
+++ b/strolle-shaders/src/gi_sampling_a.rs
@@ -15,7 +15,7 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 4)] atlas_sampler: &Sampler,
     #[spirv(descriptor_set = 1, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 1, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 3)] gi_d0: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 4)] gi_d1: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 5)] gi_d2: TexRgba32,
diff --git a/strolle-shaders/src/gi_sampling_b.rs b/strolle-shaders/src/gi_sampling_b.rs
index 6a5a1043..91034df0 100644
--- a/strolle-shaders/src/gi_sampling_b.rs
+++ b/strolle-shaders/src/gi_sampling_b.rs
@@ -25,7 +25,7 @@ pub fn main(
     #[spirv(descriptor_set = 1, binding = 4)]
     atmosphere_sky_lut_sampler: &Sampler,
     #[spirv(descriptor_set = 1, binding = 5)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 1, binding = 6)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 1, binding = 6)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 1, binding = 7)] gi_d0: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 8)] gi_d1: TexRgba32,
     #[spirv(descriptor_set = 1, binding = 9)] gi_d2: TexRgba32,
@@ -197,7 +197,7 @@ pub fn main(
 
     if gi_hit.is_some() {
         radiance *= gi_hit.gbuffer.base_color.xyz() / PI;
-        radiance += gi_hit.gbuffer.emissive;
+        radiance += gi_hit.gbuffer.emissive * 60.0;//Emissive strength should be parameterised somehow.
     }
 
     // -------------------------------------------------------------------------
diff --git a/strolle-shaders/src/gi_spatial_resampling.rs b/strolle-shaders/src/gi_spatial_resampling.rs
index 1258f634..8758e438 100644
--- a/strolle-shaders/src/gi_spatial_resampling.rs
+++ b/strolle-shaders/src/gi_spatial_resampling.rs
@@ -6,7 +6,7 @@ pub fn pick(
     #[spirv(push_constant)] params: &PassParams,
     #[spirv(descriptor_set = 0, binding = 0, uniform)] camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1)] prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 2)] prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 3, storage_buffer)]
     reservoirs: &[Vec4],
     #[spirv(descriptor_set = 0, binding = 4)] buf_d0: TexRgba32,
diff --git a/strolle-shaders/src/gi_temporal_resampling.rs b/strolle-shaders/src/gi_temporal_resampling.rs
index bfdbed74..9e60b24b 100644
--- a/strolle-shaders/src/gi_temporal_resampling.rs
+++ b/strolle-shaders/src/gi_temporal_resampling.rs
@@ -7,9 +7,9 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 0, uniform)] curr_camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 1, uniform)] prev_camera: &Camera,
     #[spirv(descriptor_set = 0, binding = 2)] curr_prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 3)] curr_prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 3)] curr_prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 4)] prev_prim_gbuffer_d0: TexRgba32,
-    #[spirv(descriptor_set = 0, binding = 5)] prev_prim_gbuffer_d1: TexRgba32,
+    #[spirv(descriptor_set = 0, binding = 5)] prev_prim_gbuffer_d1: TexRgba16,
     #[spirv(descriptor_set = 0, binding = 6)] reprojection_map: TexRgba32,
     #[spirv(descriptor_set = 0, binding = 7, storage_buffer)]
     prev_reservoirs: &[Vec4],
diff --git a/strolle-shaders/src/prim_raster.rs b/strolle-shaders/src/prim_raster.rs
index af94e2e0..ae2adb83 100644
--- a/strolle-shaders/src/prim_raster.rs
+++ b/strolle-shaders/src/prim_raster.rs
@@ -59,7 +59,6 @@ pub fn fs(
     // Outputs
     out_prim_gbuffer_d0: &mut Vec4,
     out_prim_gbuffer_d1: &mut Vec4,
-    out_surface: &mut Vec4,
     out_velocity: &mut Vec4,
 ) {
     let material = MaterialsView::new(materials)
@@ -105,12 +104,6 @@ pub fn fs(
 
     // -------------------------------------------------------------------------
 
-    *out_surface = Normal::encode(normal)
-        .extend(depth)
-        .extend(material.roughness);
-
-    // -------------------------------------------------------------------------
-
     *out_velocity = {
         let velocity = camera.clip_to_screen(curr_vertex)
             - prev_camera.clip_to_screen(prev_vertex);
diff --git a/strolle/Cargo.toml b/strolle/Cargo.toml
index a13406ee..6e301da6 100644
--- a/strolle/Cargo.toml
+++ b/strolle/Cargo.toml
@@ -12,14 +12,14 @@ strolle-shaders = { path = "../strolle-shaders" }
 bytemuck = "1.13.1"
 derivative = "2.2.0"
 fxhash = "0.2.1"
-glam = "0.24"
+glam = "0.27.0"
 guillotiere = "0.6.2"
 humantime = { version = "2.1.0", optional = true }
 image = { version = "0.24.6", default-features = false, features = ["png"] }
 log = "0.4.18"
 rand = "0.8.5"
-spirv-std = { git = "https://github.com/EmbarkStudios/rust-gpu" }
-wgpu = { version = "0.17.2", features = ["spirv"] }
+spirv-std = { git = "https://github.com/glasspangolin/rust-gpu.git" }
+wgpu = { version = "0.20.1", features = ["spirv"] }
 
 [features]
 metrics = ["humantime"]
diff --git a/strolle/src/bvh/builder.rs b/strolle/src/bvh/builder.rs
index 94108866..fdbd70d7 100644
--- a/strolle/src/bvh/builder.rs
+++ b/strolle/src/bvh/builder.rs
@@ -4,7 +4,6 @@ use std::hash::{Hash, Hasher};
 use std::thread;
 
 use fxhash::FxHasher;
-use glam::UVec3;
 
 use super::{
     BvhNode, BvhNodeHash, BvhNodeId, BvhNodes, BvhPrimitiveId, BvhPrimitives,
@@ -86,7 +85,7 @@ fn find_splitting_plane(
 
     let centroid_bb: BoundingBox = primitives
         .iter()
-        .map(|primitive| primitive.center)
+        .map(|primitive| -> glam::Vec3 {primitive.center})
         .collect();
 
     let mut bins = [[Bin::default(); BINS]; 3];
@@ -94,7 +93,7 @@ fn find_splitting_plane(
 
     for primitive in primitives {
         let bin_id = scale * (primitive.center - centroid_bb.min());
-        let bin_id = bin_id.as_uvec3().min(UVec3::splat((BINS as u32) - 1));
+        let bin_id = bin_id.as_uvec3().min(glam::UVec3::splat((BINS as u32) - 1));
         let bin_idx = bin_id.x as usize;
         let bin_idy = bin_id.y as usize;
         let bin_idz = bin_id.z as usize;
@@ -165,8 +164,8 @@ fn find_splitting_plane(
             if is_current_bin_better {
                 let split_by = Axis::from(axis);
 
-                let split_at = centroid_bb.min()[split_by]
-                    + scale[split_by] * ((i + 1) as f32);
+                let split_at = centroid_bb.min()[split_by as usize]
+                    + scale[split_by as usize] * ((i + 1) as f32);
 
                 best = Some(SplittingPlane {
                     split_by,
@@ -211,7 +210,7 @@ fn split(
     while left_prim_idx <= right_prim_idx {
         let primitive = primitives_data[left_prim_idx as usize];
 
-        if primitive.center[plane.split_by] < plane.split_at {
+        if primitive.center[plane.split_by as usize] < plane.split_at {
             left_prim_idx += 1;
             left_bounds += primitive.bounds;
 
diff --git a/strolle/src/bvh/serializer.rs b/strolle/src/bvh/serializer.rs
index 0203525d..0592157c 100644
--- a/strolle/src/bvh/serializer.rs
+++ b/strolle/src/bvh/serializer.rs
@@ -8,7 +8,7 @@ pub fn run<P>(
     materials: &Materials<P>,
     nodes: &BvhNodes,
     primitives: &BvhPrimitives,
-    buffer: &mut Vec<Vec4>,
+    buffer: &mut Vec<spirv_std::glam::Vec4>,
 ) where
     P: Params,
 {
@@ -21,7 +21,7 @@ fn serialize<P>(
     materials: &Materials<P>,
     nodes: &BvhNodes,
     primitives: &BvhPrimitives,
-    buffer: &mut Vec<Vec4>,
+    buffer: &mut Vec<spirv_std::glam::Vec4>,
     id: BvhNodeId,
 ) -> u32
 where
diff --git a/strolle/src/camera.rs b/strolle/src/camera.rs
index ea63e852..734854f0 100644
--- a/strolle/src/camera.rs
+++ b/strolle/src/camera.rs
@@ -1,9 +1,10 @@
 use std::fmt;
 
 use log::info;
-use spirv_std::glam::{uvec2, Mat4, UVec2, Vec3};
+use glam::{uvec2, Mat4, UVec2, Vec3};
 
 use crate::gpu;
+use crate::utils::ToGpu;
 
 #[derive(Clone, Debug, Default)]
 pub struct Camera {
@@ -49,19 +50,19 @@ impl Camera {
 
     pub(crate) fn serialize(&self) -> gpu::Camera {
         gpu::Camera {
-            projection_view: self.projection * self.transform.inverse(),
-            ndc_to_world: self.transform * self.projection.inverse(),
-            origin: self
+            projection_view: (self.projection * self.transform.inverse()).to_gpu(),
+            ndc_to_world: (self.transform * self.projection.inverse()).to_gpu(),
+            origin: (self
                 .transform
                 .to_scale_rotation_translation()
                 .2
-                .extend(Default::default()),
-            screen: self
+                .extend(Default::default())).to_gpu(),
+            screen: (self
                 .viewport
                 .size
                 .as_vec2()
                 .extend(Default::default())
-                .extend(Default::default()),
+                .extend(Default::default())).to_gpu(),
         }
     }
 }
diff --git a/strolle/src/camera_controller/buffers.rs b/strolle/src/camera_controller/buffers.rs
index 334278e0..b801df30 100644
--- a/strolle/src/camera_controller/buffers.rs
+++ b/strolle/src/camera_controller/buffers.rs
@@ -1,8 +1,9 @@
 use log::debug;
-
+use strolle_gpu::DiReservoirData;
 use crate::{
     gpu, Camera, DoubleBuffered, MappedUniformBuffer, StorageBuffer, Texture,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct CameraBuffers {
@@ -16,7 +17,6 @@ pub struct CameraBuffers {
     pub prim_depth: Texture,
     pub prim_gbuffer_d0: DoubleBuffered<Texture>,
     pub prim_gbuffer_d1: DoubleBuffered<Texture>,
-    pub prim_surface_map: DoubleBuffered<Texture>,
 
     pub reprojection_map: Texture,
     pub velocity_map: Texture,
@@ -99,7 +99,7 @@ impl CameraBuffers {
         // ---------------------------------------------------------------------
 
         let prim_depth = Texture::builder("prim_depth")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Depth32Float)
             .with_usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
             .build(device);
@@ -107,7 +107,7 @@ impl CameraBuffers {
         let prim_gbuffer_d0 = DoubleBuffered::<Texture>::new(
             device,
             Texture::builder("prim_gbuffer_d0")
-                .with_size(camera.viewport.size)
+                .with_size(camera.viewport.size.to_gpu())
                 .with_format(wgpu::TextureFormat::Rgba32Float)
                 .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
                 .with_usage(wgpu::TextureUsages::RENDER_ATTACHMENT),
@@ -116,17 +116,8 @@ impl CameraBuffers {
         let prim_gbuffer_d1 = DoubleBuffered::<Texture>::new(
             device,
             Texture::builder("prim_gbuffer_d1")
-                .with_size(camera.viewport.size)
-                .with_format(wgpu::TextureFormat::Rgba32Float)
-                .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
-                .with_usage(wgpu::TextureUsages::RENDER_ATTACHMENT),
-        );
-
-        let prim_surface_map = DoubleBuffered::<Texture>::new(
-            device,
-            Texture::builder("prim_surface_map")
-                .with_size(camera.viewport.size)
-                .with_format(wgpu::TextureFormat::Rgba32Float)
+                .with_size(camera.viewport.size.to_gpu())
+                .with_format(wgpu::TextureFormat::Rgba16Float)
                 .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
                 .with_usage(wgpu::TextureUsages::RENDER_ATTACHMENT),
         );
@@ -134,44 +125,46 @@ impl CameraBuffers {
         // ---------------------------------------------------------------------
 
         let reprojection_map = Texture::builder("reprojection_map")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let velocity_map = Texture::builder("velocity_map")
-            .with_size(camera.viewport.size)
-            .with_format(wgpu::TextureFormat::Rgba32Float)
+            .with_size(camera.viewport.size.to_gpu())
+            .with_format(wgpu::TextureFormat::Rgba16Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .with_usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
             .build(device);
 
         // ---------------------------------------------------------------------
 
+        let element_size = std::mem::size_of::<DiReservoirData>();
+        let element_size_round = (element_size as f32 / 32.0).ceil() as usize * 32;
         let di_reservoirs = [0, 1, 2].map(|idx| {
             StorageBuffer::new(
                 device,
                 format!("di_reservoir_{}", idx),
-                viewport_buffer_size(2 * 4 * 4),
+                viewport_buffer_size(element_size_round),
             )
         });
 
         // ---
 
         let di_diff_samples = Texture::builder("di_diff_samples")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let di_diff_prev_colors = Texture::builder("di_diff_prev_colors")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let di_diff_curr_colors = Texture::builder("di_diff_curr_colors")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -179,13 +172,13 @@ impl CameraBuffers {
         let di_diff_moments = DoubleBuffered::<Texture>::new(
             device,
             Texture::builder("di_diff_moments")
-                .with_size(camera.viewport.size)
+                .with_size(camera.viewport.size.to_gpu())
                 .with_format(wgpu::TextureFormat::Rgba32Float)
                 .with_usage(wgpu::TextureUsages::STORAGE_BINDING),
         );
 
         let di_diff_stash = Texture::builder("di_diff_stash")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -193,7 +186,7 @@ impl CameraBuffers {
         // ---
 
         let di_spec_samples = Texture::builder("di_spec_samples")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -201,19 +194,19 @@ impl CameraBuffers {
         // ---------------------------------------------------------------------
 
         let gi_d0 = Texture::builder("gi_d0")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let gi_d1 = Texture::builder("gi_d1")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let gi_d2 = Texture::builder("gi_d2")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -229,19 +222,19 @@ impl CameraBuffers {
         // ---
 
         let gi_diff_samples = Texture::builder("gi_diff_samples")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let gi_diff_prev_colors = Texture::builder("gi_diff_prev_colors")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
 
         let gi_diff_curr_colors = Texture::builder("gi_diff_curr_colors")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -249,13 +242,13 @@ impl CameraBuffers {
         let gi_diff_moments = DoubleBuffered::<Texture>::new(
             device,
             Texture::builder("gi_diff_moments")
-                .with_size(camera.viewport.size)
+                .with_size(camera.viewport.size.to_gpu())
                 .with_format(wgpu::TextureFormat::Rgba32Float)
                 .with_usage(wgpu::TextureUsages::STORAGE_BINDING),
         );
 
         let gi_diff_stash = Texture::builder("gi_diff_stash")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -263,7 +256,7 @@ impl CameraBuffers {
         // ---
 
         let gi_spec_samples = Texture::builder("gi_spec_samples")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -286,7 +279,7 @@ impl CameraBuffers {
 
         // TODO initialize lazily
         let ref_colors = Texture::builder("ref_colors")
-            .with_size(camera.viewport.size)
+            .with_size(camera.viewport.size.to_gpu())
             .with_format(wgpu::TextureFormat::Rgba32Float)
             .with_usage(wgpu::TextureUsages::STORAGE_BINDING)
             .build(device);
@@ -304,7 +297,6 @@ impl CameraBuffers {
             prim_depth,
             prim_gbuffer_d0,
             prim_gbuffer_d1,
-            prim_surface_map,
 
             reprojection_map,
             velocity_map,
diff --git a/strolle/src/camera_controller/pass.rs b/strolle/src/camera_controller/pass.rs
index 6cd288b2..9b50c2e4 100644
--- a/strolle/src/camera_controller/pass.rs
+++ b/strolle/src/camera_controller/pass.rs
@@ -42,6 +42,7 @@ where
         let mut pass =
             encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
                 label: Some(&label),
+                timestamp_writes: None,
             });
 
         pass.set_pipeline(&self.pipeline);
@@ -136,7 +137,8 @@ where
                 label: Some(&pipeline_label),
                 layout: Some(&pipeline_layout),
                 module,
-                entry_point,
+                entry_point: entry_point,
+                compilation_options: Default::default(),
             });
 
         CameraComputePass {
diff --git a/strolle/src/camera_controller/passes/bvh_heatmap.rs b/strolle/src/camera_controller/passes/bvh_heatmap.rs
index bfe0885d..efd24d0c 100644
--- a/strolle/src/camera_controller/passes/bvh_heatmap.rs
+++ b/strolle/src/camera_controller/passes/bvh_heatmap.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct BvhHeatmapPass {
@@ -41,6 +42,6 @@ impl BvhHeatmapPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, ());
+        self.pass.run(camera, encoder, size.to_gpu(), ());
     }
 }
diff --git a/strolle/src/camera_controller/passes/di_resolving.rs b/strolle/src/camera_controller/passes/di_resolving.rs
index a76699b0..d4c60883 100644
--- a/strolle/src/camera_controller/passes/di_resolving.rs
+++ b/strolle/src/camera_controller/passes/di_resolving.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct DiResolvingPass {
@@ -50,6 +51,6 @@ impl DiResolvingPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, camera.pass_params());
+        self.pass.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/di_sampling.rs b/strolle/src/camera_controller/passes/di_sampling.rs
index 60644025..51e9e82a 100644
--- a/strolle/src/camera_controller/passes/di_sampling.rs
+++ b/strolle/src/camera_controller/passes/di_sampling.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct DiSamplingPass {
@@ -46,6 +47,6 @@ impl DiSamplingPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, camera.pass_params());
+        self.pass.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/di_spatial_resampling.rs b/strolle/src/camera_controller/passes/di_spatial_resampling.rs
index 0eff3d27..beed2959 100644
--- a/strolle/src/camera_controller/passes/di_spatial_resampling.rs
+++ b/strolle/src/camera_controller/passes/di_spatial_resampling.rs
@@ -3,6 +3,7 @@ use glam::uvec2;
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct DiSpatialResamplingPass {
@@ -81,21 +82,21 @@ impl DiSpatialResamplingPass {
         self.pick_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8 / uvec2(2, 1),
+            ((camera.camera.viewport.size + 7) / 8 / uvec2(2, 1)).to_gpu(),
             camera.pass_params(),
         );
 
         self.trace_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8,
+            ((camera.camera.viewport.size + 7) / 8).to_gpu(),
             camera.pass_params(),
         );
 
         self.sample_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8 / uvec2(2, 1),
+            ((camera.camera.viewport.size + 7) / 8 / uvec2(2, 1)).to_gpu(),
             camera.pass_params(),
         );
     }
diff --git a/strolle/src/camera_controller/passes/di_temporal_resampling.rs b/strolle/src/camera_controller/passes/di_temporal_resampling.rs
index 940e744a..108d121a 100644
--- a/strolle/src/camera_controller/passes/di_temporal_resampling.rs
+++ b/strolle/src/camera_controller/passes/di_temporal_resampling.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct DiTemporalResamplingPass {
@@ -43,6 +44,6 @@ impl DiTemporalResamplingPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, camera.pass_params());
+        self.pass.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/frame_composition.rs b/strolle/src/camera_controller/passes/frame_composition.rs
index 3c36b88a..b8e07bb3 100644
--- a/strolle/src/camera_controller/passes/frame_composition.rs
+++ b/strolle/src/camera_controller/passes/frame_composition.rs
@@ -77,6 +77,7 @@ impl FrameCompositionPass {
                 vertex: wgpu::VertexState {
                     module: &engine.shaders.frame_composition_vs.0,
                     entry_point: engine.shaders.frame_composition_vs.1,
+                    compilation_options: Default::default(),
                     buffers: &[],
                 },
                 primitive: wgpu::PrimitiveState::default(),
@@ -85,6 +86,7 @@ impl FrameCompositionPass {
                 fragment: Some(wgpu::FragmentState {
                     module: &engine.shaders.frame_composition_fs.0,
                     entry_point: engine.shaders.frame_composition_fs.1,
+                    compilation_options: Default::default(),
                     targets: &[Some(wgpu::ColorTargetState {
                         format: camera.viewport.format,
                         blend: Some(wgpu::BlendState::REPLACE),
@@ -112,10 +114,12 @@ impl FrameCompositionPass {
                 resolve_target: None,
                 ops: wgpu::Operations {
                     load: wgpu::LoadOp::Load,
-                    store: true,
+                    store: wgpu::StoreOp::Store,
                 },
             })],
             depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
         });
 
         let params = gpu::FrameCompositionPassParams {
diff --git a/strolle/src/camera_controller/passes/frame_denoising.rs b/strolle/src/camera_controller/passes/frame_denoising.rs
index 557c4262..2c1410bf 100644
--- a/strolle/src/camera_controller/passes/frame_denoising.rs
+++ b/strolle/src/camera_controller/passes/frame_denoising.rs
@@ -3,6 +3,7 @@ use crate::{
     gpu, Camera, CameraBuffers, CameraComputePass, CameraController, Engine,
     Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct FrameDenoisingPass {
@@ -26,7 +27,7 @@ impl FrameDenoisingPass {
             CameraComputePass::builder("frame_denoising_reproject_di")
                 .bind([
                     &buffers.curr_camera.bind_readable(),
-                    &buffers.prim_surface_map.curr().bind_readable(),
+                    &buffers.prim_gbuffer_d0.curr().bind_readable(),
                     &buffers.reprojection_map.bind_readable(),
                 ])
                 .bind([
@@ -42,7 +43,7 @@ impl FrameDenoisingPass {
             CameraComputePass::builder("frame_denoising_reproject_gi")
                 .bind([
                     &buffers.curr_camera.bind_readable(),
-                    &buffers.prim_surface_map.curr().bind_readable(),
+                    &buffers.prim_gbuffer_d0.curr().bind_readable(),
                     &buffers.reprojection_map.bind_readable(),
                 ])
                 .bind([
@@ -58,7 +59,7 @@ impl FrameDenoisingPass {
             CameraComputePass::builder("frame_denoising_estimate_variance")
                 .bind([
                     &buffers.curr_camera.bind_readable(),
-                    &buffers.prim_surface_map.curr().bind_readable(),
+                    &buffers.prim_gbuffer_d0.curr().bind_readable(),
                 ])
                 .bind([
                     &buffers.di_diff_curr_colors.bind_readable(),
@@ -119,7 +120,7 @@ impl FrameDenoisingPass {
                     .bind([
                         &engine.noise.bind_blue_noise(),
                         &buffers.curr_camera.bind_readable(),
-                        &buffers.prim_surface_map.curr().bind_readable(),
+                        &buffers.prim_gbuffer_d0.curr().bind_readable(),
                     ])
                     .bind([
                         &wavelet.di.0.bind_readable(),
@@ -155,21 +156,21 @@ impl FrameDenoisingPass {
         self.reproject_passes[0].run(
             camera,
             encoder,
-            size,
+            size.to_gpu(),
             camera.pass_params(),
         );
 
         self.reproject_passes[1].run(
             camera,
             encoder,
-            size,
+            size.to_gpu(),
             camera.pass_params(),
         );
 
         self.estimate_variance_pass.run(
             camera,
             encoder,
-            size,
+            size.to_gpu(),
             camera.pass_params(),
         );
 
@@ -179,7 +180,7 @@ impl FrameDenoisingPass {
             pass.run(
                 camera,
                 encoder,
-                size,
+                size.to_gpu(),
                 gpu::FrameDenoisingWaveletPassParams {
                     frame: camera.frame,
                     stride: 2u32.pow(nth),
diff --git a/strolle/src/camera_controller/passes/frame_reprojection.rs b/strolle/src/camera_controller/passes/frame_reprojection.rs
index 50f0c369..5f0c44bd 100644
--- a/strolle/src/camera_controller/passes/frame_reprojection.rs
+++ b/strolle/src/camera_controller/passes/frame_reprojection.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct FrameReprojectionPass {
@@ -21,8 +22,8 @@ impl FrameReprojectionPass {
             .bind([
                 &buffers.curr_camera.bind_readable(),
                 &buffers.prev_camera.bind_readable(),
-                &buffers.prim_surface_map.curr().bind_readable(),
-                &buffers.prim_surface_map.prev().bind_readable(),
+                &buffers.prim_gbuffer_d0.curr().bind_readable(),
+                &buffers.prim_gbuffer_d0.prev().bind_readable(),
                 &buffers.velocity_map.bind_readable(),
                 &buffers.reprojection_map.bind_writable(),
             ])
@@ -39,6 +40,6 @@ impl FrameReprojectionPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, ());
+        self.pass.run(camera, encoder, size.to_gpu(), ());
     }
 }
diff --git a/strolle/src/camera_controller/passes/gi_preview_resampling.rs b/strolle/src/camera_controller/passes/gi_preview_resampling.rs
index 928523fd..1525a4e4 100644
--- a/strolle/src/camera_controller/passes/gi_preview_resampling.rs
+++ b/strolle/src/camera_controller/passes/gi_preview_resampling.rs
@@ -2,6 +2,7 @@ use crate::{
     gpu, Camera, CameraBuffers, CameraComputePass, CameraController, Engine,
     Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiPreviewResamplingPass {
@@ -23,7 +24,6 @@ impl GiPreviewResamplingPass {
                 &buffers.curr_camera.bind_readable(),
                 &buffers.prim_gbuffer_d0.curr().bind_readable(),
                 &buffers.prim_gbuffer_d1.curr().bind_readable(),
-                &buffers.prim_surface_map.curr().bind_readable(),
                 &buffers.gi_reservoirs[1].bind_readable(),
                 &buffers.gi_reservoirs[2].bind_readable(),
                 &buffers.gi_reservoirs[3].bind_writable(),
@@ -35,7 +35,6 @@ impl GiPreviewResamplingPass {
                 &buffers.curr_camera.bind_readable(),
                 &buffers.prim_gbuffer_d0.curr().bind_readable(),
                 &buffers.prim_gbuffer_d1.curr().bind_readable(),
-                &buffers.prim_surface_map.curr().bind_readable(),
                 &buffers.gi_reservoirs[1].bind_readable(),
                 &buffers.gi_reservoirs[3].bind_readable(),
                 &buffers.gi_reservoirs[0].bind_writable(),
@@ -63,7 +62,7 @@ impl GiPreviewResamplingPass {
             pass.run(
                 camera,
                 encoder,
-                size,
+                size.to_gpu(),
                 gpu::GiPreviewResamplingPass {
                     seed: params.seed,
                     frame: params.frame,
diff --git a/strolle/src/camera_controller/passes/gi_reprojection.rs b/strolle/src/camera_controller/passes/gi_reprojection.rs
index bb14458c..f02c1f9f 100644
--- a/strolle/src/camera_controller/passes/gi_reprojection.rs
+++ b/strolle/src/camera_controller/passes/gi_reprojection.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiReprojectionPass {
@@ -39,6 +40,6 @@ impl GiReprojectionPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, camera.pass_params());
+        self.pass.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/gi_resolving.rs b/strolle/src/camera_controller/passes/gi_resolving.rs
index 156176a4..2dceb26b 100644
--- a/strolle/src/camera_controller/passes/gi_resolving.rs
+++ b/strolle/src/camera_controller/passes/gi_resolving.rs
@@ -2,6 +2,7 @@ use crate::{
     gpu, Camera, CameraBuffers, CameraComputePass, CameraController, Engine,
     Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiResolvingPass {
@@ -46,7 +47,7 @@ impl GiResolvingPass {
         self.pass.run(
             camera,
             encoder,
-            size,
+            size.to_gpu(),
             gpu::GiResolvingPassParams {
                 frame: camera.frame,
                 source,
diff --git a/strolle/src/camera_controller/passes/gi_sampling.rs b/strolle/src/camera_controller/passes/gi_sampling.rs
index a805d39a..3179d735 100644
--- a/strolle/src/camera_controller/passes/gi_sampling.rs
+++ b/strolle/src/camera_controller/passes/gi_sampling.rs
@@ -3,6 +3,7 @@ use glam::uvec2;
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiSamplingPass {
@@ -72,7 +73,7 @@ impl GiSamplingPass {
         // These passes use 8x8 warps and 2x1 checkerboard:
         let size = (camera.camera.viewport.size + 7) / 8 / uvec2(2, 1);
 
-        self.pass_a.run(camera, encoder, size, camera.pass_params());
-        self.pass_b.run(camera, encoder, size, camera.pass_params());
+        self.pass_a.run(camera, encoder, size.to_gpu(), camera.pass_params());
+        self.pass_b.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/gi_spatial_resampling.rs b/strolle/src/camera_controller/passes/gi_spatial_resampling.rs
index a6c3d235..5486889d 100644
--- a/strolle/src/camera_controller/passes/gi_spatial_resampling.rs
+++ b/strolle/src/camera_controller/passes/gi_spatial_resampling.rs
@@ -3,6 +3,7 @@ use glam::uvec2;
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiSpatialResamplingPass {
@@ -74,21 +75,21 @@ impl GiSpatialResamplingPass {
         self.pick_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8 / uvec2(2, 1),
+            ((camera.camera.viewport.size + 7) / 8 / uvec2(2, 1)).to_gpu(),
             camera.pass_params(),
         );
 
         self.trace_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8,
+            ((camera.camera.viewport.size + 7) / 8).to_gpu(),
             camera.pass_params(),
         );
 
         self.sample_pass.run(
             camera,
             encoder,
-            (camera.camera.viewport.size + 7) / 8 / uvec2(2, 1),
+            ((camera.camera.viewport.size + 7) / 8 / uvec2(2, 1)).to_gpu(),
             camera.pass_params(),
         );
     }
diff --git a/strolle/src/camera_controller/passes/gi_temporal_resampling.rs b/strolle/src/camera_controller/passes/gi_temporal_resampling.rs
index f8957799..4d1553ef 100644
--- a/strolle/src/camera_controller/passes/gi_temporal_resampling.rs
+++ b/strolle/src/camera_controller/passes/gi_temporal_resampling.rs
@@ -1,6 +1,7 @@
 use crate::{
     Camera, CameraBuffers, CameraComputePass, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct GiTemporalResamplingPass {
@@ -42,6 +43,6 @@ impl GiTemporalResamplingPass {
         // This pass uses 8x8 warps:
         let size = (camera.camera.viewport.size + 7) / 8;
 
-        self.pass.run(camera, encoder, size, camera.pass_params());
+        self.pass.run(camera, encoder, size.to_gpu(), camera.pass_params());
     }
 }
diff --git a/strolle/src/camera_controller/passes/prim_raster.rs b/strolle/src/camera_controller/passes/prim_raster.rs
index 15a5f4c3..325dc637 100644
--- a/strolle/src/camera_controller/passes/prim_raster.rs
+++ b/strolle/src/camera_controller/passes/prim_raster.rs
@@ -7,6 +7,7 @@ use log::debug;
 use crate::{
     gpu, BindGroup, Camera, CameraBuffers, CameraController, Engine, Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct PrimRasterPass {
@@ -57,6 +58,7 @@ impl PrimRasterPass {
                 vertex: wgpu::VertexState {
                     module: &engine.shaders.prim_raster_vs.0,
                     entry_point: engine.shaders.prim_raster_vs.1,
+                    compilation_options: Default::default(),
                     buffers: &[wgpu::VertexBufferLayout {
                         array_stride: (3 * 4 * mem::size_of::<f32>()) as _,
                         step_mode: wgpu::VertexStepMode::Vertex,
@@ -102,6 +104,7 @@ impl PrimRasterPass {
                 fragment: Some(wgpu::FragmentState {
                     module: &engine.shaders.prim_raster_fs.0,
                     entry_point: engine.shaders.prim_raster_fs.1,
+                    compilation_options: Default::default(),
                     targets: &[
                         Some(wgpu::ColorTargetState {
                             format: wgpu::TextureFormat::Rgba32Float,
@@ -109,17 +112,12 @@ impl PrimRasterPass {
                             write_mask: wgpu::ColorWrites::ALL,
                         }),
                         Some(wgpu::ColorTargetState {
-                            format: wgpu::TextureFormat::Rgba32Float,
+                            format: wgpu::TextureFormat::Rgba16Float,
                             blend: Some(wgpu::BlendState::REPLACE),
                             write_mask: wgpu::ColorWrites::ALL,
                         }),
                         Some(wgpu::ColorTargetState {
-                            format: wgpu::TextureFormat::Rgba32Float,
-                            blend: Some(wgpu::BlendState::REPLACE),
-                            write_mask: wgpu::ColorWrites::ALL,
-                        }),
-                        Some(wgpu::ColorTargetState {
-                            format: wgpu::TextureFormat::Rgba32Float,
+                            format: wgpu::TextureFormat::Rgba16Float,
                             blend: Some(wgpu::BlendState::REPLACE),
                             write_mask: wgpu::ColorWrites::ALL,
                         }),
@@ -149,7 +147,7 @@ impl PrimRasterPass {
                     resolve_target: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                        store: true,
+                        store: wgpu::StoreOp::Store,
                     },
                 }),
                 Some(wgpu::RenderPassColorAttachment {
@@ -157,15 +155,7 @@ impl PrimRasterPass {
                     resolve_target: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                        store: true,
-                    },
-                }),
-                Some(wgpu::RenderPassColorAttachment {
-                    view: camera.buffers.prim_surface_map.get(alternate).view(),
-                    resolve_target: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                        store: true,
+                        store: wgpu::StoreOp::Store,
                     },
                 }),
                 Some(wgpu::RenderPassColorAttachment {
@@ -173,7 +163,7 @@ impl PrimRasterPass {
                     resolve_target: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                        store: true,
+                        store: wgpu::StoreOp::Store,
                     },
                 }),
             ],
@@ -182,11 +172,13 @@ impl PrimRasterPass {
                     view: camera.buffers.prim_depth.view(),
                     depth_ops: Some(wgpu::Operations {
                         load: wgpu::LoadOp::Clear(0.0),
-                        store: true,
+                        store: wgpu::StoreOp::Store,
                     }),
                     stencil_ops: None,
                 },
             ),
+            timestamp_writes: None,
+            occlusion_query_set: None,
         });
 
         pass.set_pipeline(&self.pipeline);
@@ -204,11 +196,11 @@ impl PrimRasterPass {
 
             let params = {
                 let curr_xform_inv = gpu::PrimRasterPassParams::encode_affine(
-                    instance.transform_inverse,
+                    instance.transform_inverse.to_gpu(),
                 );
 
                 let prev_xform = gpu::PrimRasterPassParams::encode_affine(
-                    instance_entry.prev_transform,
+                    instance_entry.prev_transform.to_gpu(),
                 );
 
                 gpu::PrimRasterPassParams {
@@ -217,7 +209,7 @@ impl PrimRasterPass {
                         f32::from_bits(material_id.get()),
                         Default::default(),
                         Default::default(),
-                    ),
+                    ).to_gpu(),
                     curr_xform_inv_d0: curr_xform_inv[0],
                     curr_xform_inv_d1: curr_xform_inv[1],
                     curr_xform_inv_d2: curr_xform_inv[2],
diff --git a/strolle/src/camera_controller/passes/ref_shading.rs b/strolle/src/camera_controller/passes/ref_shading.rs
index 604e67f1..31402c02 100644
--- a/strolle/src/camera_controller/passes/ref_shading.rs
+++ b/strolle/src/camera_controller/passes/ref_shading.rs
@@ -4,6 +4,7 @@ use crate::{
     gpu, Camera, CameraBuffers, CameraComputePass, CameraController, Engine,
     Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct RefShadingPass {
@@ -58,6 +59,6 @@ impl RefShadingPass {
             depth: depth as u32,
         };
 
-        self.pass.run(camera, encoder, size, params);
+        self.pass.run(camera, encoder, size.to_gpu(), params);
     }
 }
diff --git a/strolle/src/camera_controller/passes/ref_tracing.rs b/strolle/src/camera_controller/passes/ref_tracing.rs
index 643a1aab..f083e821 100644
--- a/strolle/src/camera_controller/passes/ref_tracing.rs
+++ b/strolle/src/camera_controller/passes/ref_tracing.rs
@@ -4,6 +4,7 @@ use crate::{
     gpu, Camera, CameraBuffers, CameraComputePass, CameraController, Engine,
     Params,
 };
+use crate::utils::ToGpu;
 
 #[derive(Debug)]
 pub struct RefTracingPass {
@@ -52,6 +53,6 @@ impl RefTracingPass {
             depth: depth as u32,
         };
 
-        self.pass.run(camera, encoder, size, params);
+        self.pass.run(camera, encoder, size.to_gpu(), params);
     }
 }
diff --git a/strolle/src/images.rs b/strolle/src/images.rs
index 3a685fa4..eac8b757 100644
--- a/strolle/src/images.rs
+++ b/strolle/src/images.rs
@@ -5,8 +5,9 @@ use derivative::Derivative;
 use glam::{uvec2, vec4, Vec4};
 use guillotiere::{size2, Allocation, AtlasAllocator};
 use log::warn;
-
+use wgpu::TextureFormat;
 use crate::{Bindable, Image, ImageData, Params, Texture};
+use crate::utils::ToGpu;
 
 #[derive(Derivative)]
 #[derivative(Debug)]
@@ -22,6 +23,40 @@ where
     dynamic_textures: Vec<(P::ImageTexture, Allocation)>,
 }
 
+fn convert_to_rgba8unorm_srgb(
+    data: &[u8],
+    src_format: wgpu::TextureFormat,
+    width: u32,
+    height: u32,
+) -> Vec<u8> {
+    let pixel_count = (width * height) as usize;
+    let mut converted_data = Vec::with_capacity(pixel_count * 4);
+
+    match src_format {
+        wgpu::TextureFormat::R8Unorm => {
+            for &r in data {
+                converted_data.extend_from_slice(&[r, 0, 0, 255]);
+            }
+        }
+        wgpu::TextureFormat::Rg8Unorm => {
+            for chunk in data.chunks_exact(2) {
+                let r = chunk[0];
+                let g = chunk[1];
+                converted_data.extend_from_slice(&[r, g, 0, 255]);
+            }
+        }
+        wgpu::TextureFormat::Rgba8UnormSrgb => {
+            converted_data.extend_from_slice(data);
+        }
+        _ => {
+            println!("Unhandled texture format: {:?}", src_format);
+        }
+    }
+
+    converted_data
+}
+
+
 impl<P> Images<P>
 where
     P: Params,
@@ -36,7 +71,7 @@ where
         ));
 
         let atlas_texture = Texture::builder("atlas")
-            .with_size(uvec2(Self::ATLAS_WIDTH, Self::ATLAS_HEIGHT))
+            .with_size(uvec2(Self::ATLAS_WIDTH, Self::ATLAS_HEIGHT).to_gpu())
             .with_format(wgpu::TextureFormat::Rgba8UnormSrgb)
             .with_usage(wgpu::TextureUsages::TEXTURE_BINDING)
             .with_usage(wgpu::TextureUsages::COPY_DST)
@@ -85,13 +120,55 @@ where
             | ImageData::Texture {
                 is_dynamic: false, ..
             }) => {
-                self.atlas_changes.push(AtlasChange::Set {
-                    x: alloc.rectangle.min.x as u32,
-                    y: alloc.rectangle.min.y as u32,
-                    w: alloc.rectangle.width() as u32,
-                    h: alloc.rectangle.height() as u32,
-                    data,
-                });
+                match &data {
+                    ImageData::Raw { data } => {
+                        // Convert data to atlas format (Rgba8UnormSrgb)
+                        let converted_data = convert_to_rgba8unorm_srgb(
+                            data,
+                            item.texture_descriptor.format,
+                            item.texture_descriptor.size.width,
+                            item.texture_descriptor.size.height,
+                        );
+
+                        // Use atlas texture's format for calculations
+                        let block_size = 4; // Rgba8UnormSrgb has 4 bytes per pixel
+                        let unpadded_bytes_per_row =
+                            item.texture_descriptor.size.width * block_size;
+                        let padding = (256 - (unpadded_bytes_per_row % 256)) % 256;
+                        let padded_bytes_per_row = unpadded_bytes_per_row + padding;
+
+                        // Pad the converted data if necessary
+                        let mut padded_data = Vec::with_capacity(
+                            (padded_bytes_per_row * item.texture_descriptor.size.height) as usize,
+                        );
+                        if padding == 0 {
+                            padded_data = converted_data;
+                        } else {
+                            let row_length = (unpadded_bytes_per_row) as usize;
+                            for row in converted_data.chunks_exact(row_length) {
+                                padded_data.extend_from_slice(row);
+                                padded_data.extend(std::iter::repeat(0).take(padding as usize));
+                            }
+                        }
+
+                        self.atlas_changes.push(AtlasChange::Set {
+                            x: alloc.rectangle.min.x as u32,
+                            y: alloc.rectangle.min.y as u32,
+                            w: alloc.rectangle.width() as u32,
+                            h: alloc.rectangle.height() as u32,
+                            data: ImageData::Raw { data: padded_data },
+                        });
+                    }
+                    ImageData::Texture { texture, .. } => {
+                        self.atlas_changes.push(AtlasChange::Set {
+                            x: alloc.rectangle.min.x as u32,
+                            y: alloc.rectangle.min.y as u32,
+                            w: alloc.rectangle.width() as u32,
+                            h: alloc.rectangle.height() as u32,
+                            data: data,
+                        });
+                    }
+                };
             }
 
             ImageData::Texture {
@@ -140,6 +217,23 @@ where
 
                     match data {
                         ImageData::Raw { data } => {
+                            // Use atlas texture's format for calculations
+                            let block_size = 4; // Rgba8UnormSrgb has 4 bytes per pixel
+                            let unpadded_bytes_per_row = w * block_size;
+                            let padding = (256 - (unpadded_bytes_per_row % 256)) % 256;
+                            let padded_bytes_per_row = unpadded_bytes_per_row + padding;
+
+                            println!(
+                                "Writing texture: pos={}x{}, size={}x{}, data_len={}, bytes_per_row={}, padded_bytes_per_row={}",
+                                x,
+                                y,
+                                w,
+                                h,
+                                data.len(),
+                                unpadded_bytes_per_row,
+                                padded_bytes_per_row
+                            );
+
                             queue.write_texture(
                                 wgpu::ImageCopyTexture {
                                     texture: self.atlas_texture.tex(),
@@ -150,14 +244,10 @@ where
                                 &data,
                                 wgpu::ImageDataLayout {
                                     offset: 0,
-                                    bytes_per_row: Some(w * 4),
+                                    bytes_per_row: Some(padded_bytes_per_row),
                                     rows_per_image: None,
                                 },
-                                wgpu::Extent3d {
-                                    width: w,
-                                    height: h,
-                                    depth_or_array_layers: 1,
-                                },
+                                size,
                             );
                         }
 
diff --git a/strolle/src/lib.rs b/strolle/src/lib.rs
index 0f1bd294..e8b8a754 100644
--- a/strolle/src/lib.rs
+++ b/strolle/src/lib.rs
@@ -75,10 +75,12 @@ use std::ops::Deref;
 use std::time::Instant;
 use std::{env, mem};
 
-pub use glam;
+use glam;
 use log::{info, trace};
 use strolle_gpu as gpu;
 
+pub use crate::utils::interface::ToGpu;
+
 pub(crate) use self::buffers::*;
 pub(crate) use self::bvh::*;
 pub use self::camera::*;
diff --git a/strolle/src/light.rs b/strolle/src/light.rs
index 6440270e..c8b470f5 100644
--- a/strolle/src/light.rs
+++ b/strolle/src/light.rs
@@ -1,6 +1,7 @@
 use glam::{vec4, Vec3};
 
 use crate::gpu;
+use crate::utils::ToGpu;
 
 #[derive(Clone, Debug)]
 pub enum Light {
@@ -53,7 +54,7 @@ impl Light {
                 direction,
                 angle,
             } => {
-                let direction = gpu::Normal::encode(*direction);
+                let direction = gpu::Normal::encode((*direction).to_gpu());
 
                 d0 = position.extend(*radius);
                 d1 = color.extend(*range);
@@ -68,9 +69,9 @@ impl Light {
         }
 
         gpu::Light {
-            d0,
-            d1,
-            d2,
+            d0: d0.to_gpu(),
+            d1: d1.to_gpu(),
+            d2: d2.to_gpu(),
             d3: Default::default(),
             prev_d0: Default::default(),
             prev_d1: Default::default(),
diff --git a/strolle/src/material.rs b/strolle/src/material.rs
index 1d79abda..cd012431 100644
--- a/strolle/src/material.rs
+++ b/strolle/src/material.rs
@@ -3,6 +3,7 @@ use std::fmt::Debug;
 use spirv_std::glam::{vec4, Vec4};
 
 use crate::{gpu, Images, Params};
+use crate::utils::ToGpu;
 
 #[derive(Clone, Debug)]
 pub struct Material<P>
@@ -31,21 +32,21 @@ where
             base_color: self.base_color,
             base_color_texture: images
                 .lookup_opt(self.base_color_texture)
-                .unwrap_or_default(),
+                .unwrap_or_default().to_gpu(),
             emissive: self.emissive,
             emissive_texture: images
                 .lookup_opt(self.emissive_texture)
-                .unwrap_or_default(),
+                .unwrap_or_default().to_gpu(),
             roughness: self.perceptual_roughness.powf(2.0),
             metallic: self.metallic,
             metallic_roughness_texture: images
                 .lookup_opt(self.metallic_roughness_texture)
-                .unwrap_or_default(),
+                .unwrap_or_default().to_gpu(),
             reflectance: self.reflectance,
             ior: self.ior,
             normal_map_texture: images
                 .lookup_opt(self.normal_map_texture)
-                .unwrap_or_default(),
+                .unwrap_or_default().to_gpu(),
         }
     }
 }
diff --git a/strolle/src/mesh_triangle.rs b/strolle/src/mesh_triangle.rs
index 3a5d38e7..d7e7bb59 100644
--- a/strolle/src/mesh_triangle.rs
+++ b/strolle/src/mesh_triangle.rs
@@ -1,6 +1,5 @@
-use glam::Affine3A;
-use spirv_std::glam::{Mat4, Vec2, Vec3, Vec4, Vec4Swizzles};
 
+use glam::{Vec2, Vec3, Vec4, Mat4, Affine3A, Vec4Swizzles};
 use crate::Triangle;
 
 #[derive(Clone, Debug, Default)]
@@ -17,17 +16,17 @@ impl MeshTriangle {
         self
     }
 
-    pub fn with_normals(mut self, normals: [impl Into<Vec3>; 3]) -> Self {
-        self.normals = normals.map(Into::into);
+    pub fn with_normals(mut self, normals: [Vec3; 3]) -> Self {
+        self.normals = normals;
         self
     }
 
-    pub fn with_uvs(mut self, uvs: [impl Into<Vec2>; 3]) -> Self {
-        self.uvs = uvs.map(Into::into);
+    pub fn with_uvs(mut self, uvs: [Vec2; 3]) -> Self {
+        self.uvs = uvs;
         self
     }
 
-    pub fn with_tangents(mut self, tangents: [impl Into<Vec4>; 3]) -> Self {
+    pub fn with_tangents(mut self, tangents: [Vec4; 3]) -> Self {
         self.tangents = tangents.map(Into::into);
         self
     }
@@ -49,8 +48,8 @@ impl MeshTriangle {
         xform: Affine3A,
         xform_inv: Affine3A,
     ) -> Triangle {
-        let positions =
-            self.positions.map(|vertex| xform.transform_point3(vertex));
+        let positions: [Vec3; 3] =
+            self.positions.map(|vertex: Vec3| -> Vec3 {xform.transform_point3(vertex)});
 
         let normals = {
             // Transforming normals requires inversing and transposing the
@@ -77,10 +76,12 @@ impl MeshTriangle {
             })
         };
 
+        let uvs = self.uvs.map(|uv| {uv});
+
         Triangle {
             positions,
             normals,
-            uvs: self.uvs,
+            uvs,
             tangents,
         }
     }
diff --git a/strolle/src/triangle.rs b/strolle/src/triangle.rs
index 50d80dba..73694b4e 100644
--- a/strolle/src/triangle.rs
+++ b/strolle/src/triangle.rs
@@ -1,8 +1,8 @@
 use glam::Vec3Swizzles;
-use spirv_std::glam::{Vec2, Vec3, Vec4};
+use glam::{Vec2, Vec3, Vec4};
 
 use crate::gpu;
-use crate::utils::BoundingBox;
+use crate::utils::{BoundingBox, ToGpu};
 
 #[derive(Clone, Debug)]
 pub struct Triangle {
@@ -23,17 +23,17 @@ impl Triangle {
 
     pub fn serialize(&self) -> gpu::Triangle {
         gpu::Triangle {
-            d0: self.positions[0].xyz().extend(self.uvs[0].x),
-            d1: self.normals[0].xyz().extend(self.uvs[0].y),
-            d2: self.tangents[0],
+            d0: self.positions[0].xyz().extend(self.uvs[0].x).to_gpu(),
+            d1: self.normals[0].xyz().extend(self.uvs[0].y).to_gpu(),
+            d2: self.tangents[0].to_gpu(),
 
-            d3: self.positions[1].xyz().extend(self.uvs[1].x),
-            d4: self.normals[1].xyz().extend(self.uvs[1].y),
-            d5: self.tangents[1],
+            d3: self.positions[1].xyz().extend(self.uvs[1].x).to_gpu(),
+            d4: self.normals[1].xyz().extend(self.uvs[1].y).to_gpu(),
+            d5: self.tangents[1].to_gpu(),
 
-            d6: self.positions[2].xyz().extend(self.uvs[2].x),
-            d7: self.normals[2].xyz().extend(self.uvs[2].y),
-            d8: self.tangents[2],
+            d6: self.positions[2].xyz().extend(self.uvs[2].x).to_gpu(),
+            d7: self.normals[2].xyz().extend(self.uvs[2].y).to_gpu(),
+            d8: self.tangents[2].to_gpu(),
         }
     }
 }
diff --git a/strolle/src/utils.rs b/strolle/src/utils.rs
index e3c81beb..0c319b80 100644
--- a/strolle/src/utils.rs
+++ b/strolle/src/utils.rs
@@ -2,8 +2,12 @@ mod allocator;
 mod axis;
 mod bounding_box;
 mod metrics;
+pub mod interface;
 
 pub use self::allocator::*;
 pub use self::axis::*;
 pub use self::bounding_box::*;
 pub use self::metrics::*;
+pub use self::interface::*;
+
+
diff --git a/strolle/src/utils/bounding_box.rs b/strolle/src/utils/bounding_box.rs
index 6ff28a9f..681f95b5 100644
--- a/strolle/src/utils/bounding_box.rs
+++ b/strolle/src/utils/bounding_box.rs
@@ -1,6 +1,6 @@
 use std::ops::{Add, AddAssign};
 
-use spirv_std::glam::Vec3;
+use glam::Vec3;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct BoundingBox {
diff --git a/strolle/src/utils/interface.rs b/strolle/src/utils/interface.rs
new file mode 100644
index 00000000..521f1dcf
--- /dev/null
+++ b/strolle/src/utils/interface.rs
@@ -0,0 +1,58 @@
+// First, let's define helper traits for converting between CPU and GPU types
+use glam as cpu;
+use spirv_std::glam as gpu;
+
+// Helper trait for converting CPU types to GPU types
+pub trait ToGpu<T> {
+    fn to_gpu(&self) -> T;
+}
+
+
+impl ToGpu<gpu::Affine3A> for cpu::Affine3A {
+    fn to_gpu(&self) -> gpu::Affine3A {
+        gpu::Affine3A::from_cols_array(&self.to_cols_array())
+    }
+}
+
+impl ToGpu<gpu::Mat4> for cpu::Mat4 {
+    fn to_gpu(&self) -> gpu::Mat4 {
+        gpu::Mat4::from_cols_array(&self.to_cols_array())
+    }
+}
+
+impl ToGpu<gpu::Vec4> for cpu::Vec4 {
+    fn to_gpu(&self) -> gpu::Vec4 {
+        gpu::Vec4::new(self.x, self.y, self.z, self.w)
+    }
+}
+
+impl ToGpu<gpu::Vec3> for cpu::Vec3 {
+    fn to_gpu(&self) -> gpu::Vec3 {
+        gpu::Vec3::new(self.x, self.y, self.z)
+    }
+}
+
+impl ToGpu<gpu::Vec2> for cpu::Vec2 {
+    fn to_gpu(&self) -> gpu::Vec2 {
+        gpu::Vec2::new(self.x, self.y)
+    }
+}
+
+
+impl ToGpu<gpu::UVec2> for cpu::UVec2 {
+    fn to_gpu(&self) -> gpu::UVec2 {
+        gpu::UVec2::new(self.x, self.y)
+    }
+}
+
+impl ToGpu<gpu::UVec3> for cpu::UVec3 {
+    fn to_gpu(&self) -> gpu::UVec3 {
+        gpu::UVec3::new(self.x, self.y, self.z)
+    }
+}
+
+impl ToGpu<gpu::UVec4> for cpu::UVec4 {
+    fn to_gpu(&self) -> gpu::UVec4 {
+        gpu::UVec4::new(self.x, self.y, self.z, self.w)
+    }
+}
\ No newline at end of file

From b37c66a40baa72e4cae23c0c6cde8e17eef6ba6f Mon Sep 17 00:00:00 2001
From: glasspangolin <23103433+glasspangolin@users.noreply.github.com>
Date: Mon, 18 Nov 2024 19:11:52 +1100
Subject: [PATCH 2/2] - Found a nicer workaround to the inline const problem,
 although this does involve patching all bevy dependencies to add one line.
 This might be palatable because it is a similar style to the removed naga
 patch. - Fixed one last example of newer WGPU versions being fussy with u8
 cast as u32.

---
 .gitignore                         |  2 ++
 Cargo.toml                         | 34 ++++++++++++++++++++++++++++++
 strolle-shaders/src/ref_shading.rs |  2 +-
 3 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index f6433629..3e54d49a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,5 @@ target
 /bevy-strolle/examples/bench-*
 /bevy-strolle/examples/scene*
 /Cargo.lock
+Cargo.lock
+*.lock
diff --git a/Cargo.toml b/Cargo.toml
index 5943300c..05ac7740 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,3 +9,37 @@ members = [
     "strolle-shaders",
 ]
 
+[patch."crates-io"]
+bevy = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_render = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_ptr = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_utils = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_tasks = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_reflect = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_mikktspace = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_ecs = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_math = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_app = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_color = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_core = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_asset = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_a11y = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_time = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_hierarchy = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_window = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_diagnostic = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_gilrs = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_transform = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_state = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_winit = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_audio = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_core_pipeline = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_animation = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_scene = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_sprite = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_pbr = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_gizmos = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_text = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_gltf = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_ui = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
+bevy_internal = { git = "https://github.com/glasspangolin/bevy", branch = "v0.14.2-strolle" }
\ No newline at end of file
diff --git a/strolle-shaders/src/ref_shading.rs b/strolle-shaders/src/ref_shading.rs
index e71214a2..a6c1acaf 100644
--- a/strolle-shaders/src/ref_shading.rs
+++ b/strolle-shaders/src/ref_shading.rs
@@ -50,7 +50,7 @@ pub fn main(
 
     // -------------------------------------------------------------------------
 
-    if params.depth == u8::MAX as u32 {
+    if params.depth == 255u32 {
         let prev_color = if camera.is_eq(*prev_camera) {
             colors.read(screen_pos)
         } else {