Basic shadow-mapping

.gitignore

···
-/target
-/pkg
+# Rust
+target/
+**/*.rs.bk
+
+# cargo-mobile
+.cargo/
+/gen
+
+# macOS
 .DS_Store
-save.bl0ck

Cargo.lock

···
  "fs_extra",
  "futures",
  "glam",
- "glob",
  "image",
  "itertools",
  "log",
···
 dependencies = [
  "bytemuck",
 ]
-
-[[package]]
-name = "glob"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
 [[package]]
 name = "glow"
···
 dependencies = [
  "rand_chacha",
  "rand_core",
- "zerocopy 0.8.16",
+ "zerocopy 0.8.17",
 ]
 
 [[package]]
···
 checksum = "b08f3c9802962f7e1b25113931d94f43ed9725bebc59db9d0c3e9a23b67e15ff"
 dependencies = [
  "getrandom 0.3.1",
- "zerocopy 0.8.16",
+ "zerocopy 0.8.17",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.50"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+checksum = "cc7ec4f8827a71586374db3e87abdb5a2bb3a15afed140221307c3ec06b1f63b"
 dependencies = [
  "cfg-if",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
···
 
 [[package]]
 name = "winit"
-version = "0.30.8"
+version = "0.30.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d74280aabb958072864bff6cfbcf9025cf8bfacdde5e32b5e12920ef703b0f"
+checksum = "a809eacf18c8eca8b6635091543f02a5a06ddf3dad846398795460e6e0ae3cc0"
 dependencies = [
  "ahash",
  "android-activity",
···
 
 [[package]]
 name = "zerocopy"
-version = "0.8.16"
+version = "0.8.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b8c07a70861ce02bad1607b5753ecb2501f67847b9f9ada7c160fff0ec6300c"
+checksum = "aa91407dacce3a68c56de03abe2760159582b846c6a4acd2f456618087f12713"
 dependencies = [
- "zerocopy-derive 0.8.16",
+ "zerocopy-derive 0.8.17",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.16"
+version = "0.8.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5226bc9a9a9836e7428936cde76bb6b22feea1a8bfdbc0d241136e4d13417e25"
+checksum = "06718a168365cad3d5ff0bb133aad346959a2074bd4a85c121255a11304a8626"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

···
 
 [build-dependencies]
 fs_extra = "1.3"
-glob = "0.3"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
···
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1.6"
 console_log = "1.0"
-wgpu = { version = "24", features = ["webgl"]}
+wgpu = { version = "24", features = ["webgl"] }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 web-sys = { version = "0.3", features = [
···
     "Window",
     "Element",
     "Location",
-]}
+] }
 reqwest = "0.12"

src/gfx.rs

···
+use std::borrow::Borrow;
 mod camera;
+mod light;
 mod model;
 mod resources;
 mod texture;
 
-use std::sync::Arc;
-
+use egui::text_selection::text_cursor_state::slice_char_range;
+use egui::Key::A;
 use egui_wgpu::ScreenDescriptor;
-use glam::{vec3, IVec3, Quat, Vec3};
+use glam::{vec3, IVec3, Mat4, Quat, Vec3, Vec4, Vec4Swizzles};
+use light::LightUniform;
+use std::ops::Deref;
+use std::{f32::consts::PI, path::Path, sync::Arc};
 use wgpu::util::DeviceExt;
+use wgpu::BindingResource;
 use winit::{
     dpi::PhysicalSize,
     event::{ElementState, KeyEvent, WindowEvent},
···
     window::Window,
 };
 
+use crate::gfx::camera::CameraUniform;
+use crate::gfx::model::DrawLight;
 use crate::{
-    app::WASM_WIN_SIZE, gfx::model::Vertex, gui::EguiRenderer, world::map::{sl3get, Block, WorldMap, CHUNK_SIZE}, world::World, Instance, InstanceRaw
+    app::WASM_WIN_SIZE,
+    gfx::model::Vertex,
+    gui::EguiRenderer,
+    world::map::{sl3get, Block, WorldMap, CHUNK_SIZE},
+    world::World,
+    Instance, InstanceRaw,
 };
 
-#[repr(C)]
-#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
-pub(crate) struct LightUniform {
-    position: Vec3,
-    _pad: u32,
-    color: Vec3,
-    _pad2: u32,
-}
-impl LightUniform {
-    pub fn new(position: Vec3, color: Vec3) -> LightUniform {
-        LightUniform {
-            position,
-            color,
-            _pad: 0,
-            _pad2: 0,
-        }
-    }
-}
-
 pub struct CameraState {
-    pub positioning: camera::Camera,
+    pub object: camera::Camera,
     pub controller: camera::CameraController,
-    pub uniform: camera::CameraUniform,
-    pub buffer: wgpu::Buffer,
-    pub bind_group: wgpu::BindGroup,
+    pub uniform: CameraUniform,
 }
 pub struct InteractState {
     pub clear_color: wgpu::Color,
···
 }
 
 pub struct LightState {
-    pub uniform: LightUniform,
-    pub buffer: wgpu::Buffer,
-    pub bind_group: wgpu::BindGroup,
+    pub object: camera::Camera,
+    pub uniform: CameraUniform,
+    pub shadow_map: texture::Texture,
 }
 
 pub struct RenderPipelines {
···
     vertex_layouts: &[wgpu::VertexBufferLayout],
     shader: wgpu::ShaderModuleDescriptor,
     polygon_mode: wgpu::PolygonMode,
+    label: Option<&str>,
 ) -> wgpu::RenderPipeline {
     let shader = device.create_shader_module(shader);
 
     device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-        label: Some("Render Pipeline"),
+        label,
         layout: Some(layout),
         vertex: wgpu::VertexState {
             module: &shader,
···
     })
 }
 
+pub enum OneOrTwo<T> {
+    One(T),
+    Two(T, T),
+}
+
+impl<T> OneOrTwo<T> {
+    pub fn one(&mut self) -> &mut T {
+        match self {
+            OneOrTwo::One(t) => t,
+            OneOrTwo::Two(_, _) => {
+                panic!("Used one() on a Two.")
+            }
+        }
+    }
+    pub fn two(&mut self) -> (&mut T, &mut T) {
+        match self {
+            OneOrTwo::One(t) => panic!("Used two() on a One."),
+            OneOrTwo::Two(x, y) => (x, y),
+        }
+    }
+}
+pub struct Pass {
+    pipeline: OneOrTwo<wgpu::RenderPipeline>,
+    bind_group: wgpu::BindGroup,
+    uniform_bufs: Vec<wgpu::Buffer>,
+}
+
 pub struct Gfx {
     pub surface: wgpu::Surface<'static>,
     pub device: wgpu::Device,
     pub queue: wgpu::Queue,
     pub surface_config: wgpu::SurfaceConfiguration,
-    pub render_pipelines: RenderPipelines,
+    // pub render_pipelines: RenderPipelines,
     pub depth_texture: texture::Texture,
+
+    // pub shadow_map_buffer: wgpu::Buffer,
+    // pub shadow_bind_group: wgpu::BindGroup,
+    pub shadow_pass: Pass,
+    pub forward_pass: Pass,
 
     pub object: ObjectState,
     pub camera: CameraState,
···
             target: Vec3::ZERO,
             up: Vec3::Y,
             aspect: surface_config.width as f32 / surface_config.height as f32,
-            fovy: 45.0,
+            fovy: PI / 2.,
             znear: 0.1,
             zfar: 1000.0,
         };
         let camera_controller = camera::CameraController::new(0.2);
         let mut camera_uniform = camera::CameraUniform::new();
         camera_uniform.update_view_proj(&camera);
-        let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Camera Buffer"),
-            contents: bytemuck::cast_slice(&[camera_uniform]),
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-        });
-        let camera_bind_group_layout =
-            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                entries: &[wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Buffer {
-                        ty: wgpu::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                }],
-                label: Some("camera_bind_group_layout"),
-            });
-        let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            layout: &camera_bind_group_layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: camera_buffer.as_entire_binding(),
-            }],
-            label: Some("camera_bind_group"),
-        });
+
+        // let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        //     layout: &camera_bind_group_layout,
+        //     entries: &[wgpu::BindGroupEntry {
+        //         binding: 0,
+        //         resource: camera_buffer.as_entire_binding(),
+        //     }],
+        //     label: Some("camera_bind_group"),
+        // });
         let camera_state = CameraState {
-            positioning: camera,
+            object: camera,
             controller: camera_controller,
             uniform: camera_uniform,
-            buffer: camera_buffer,
-            bind_group: camera_bind_group,
         };
 
         // MAP LOAD
···
         .await
         .unwrap();
 
-        let light_uniform = LightUniform::new(Vec3::splat(90.0).with_y(40.0), vec3(1.0, 1.0, 0.5));
+        log::info!("Light setup!");
+        let light = camera::Camera {
+            eye: vec3(90., 40., 90.),
+            target: Vec3::ZERO,
+            up: Vec3::Y,
+            aspect: surface_config.width as f32 / surface_config.height as f32,
+            fovy: PI / 2.,
+            znear: 0.1,
+            zfar: 1000.0,
+        };
+        let mut light_uniform = camera::CameraUniform::new();
+        light_uniform.update_view_proj(&light);
+
+        //let light_uniform = LightUniform::new(Vec3::splat(90.0).with_y(40.0), vec3(1.0, 1.0, 1.0));
 
-        let light_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Light VB"),
-            contents: bytemuck::cast_slice(&[light_uniform]),
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        log::info!("Shadowmap setup!");
+        let shadow_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Shadow Sampler"),
+            address_mode_u: wgpu::AddressMode::ClampToEdge,
+            address_mode_v: wgpu::AddressMode::ClampToEdge,
+            address_mode_w: wgpu::AddressMode::ClampToEdge,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            mipmap_filter: wgpu::FilterMode::Nearest,
+            compare: Some(wgpu::CompareFunction::LessEqual),
+            ..Default::default()
         });
 
-        let light_bind_group_layout =
-            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                entries: &[wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Buffer {
-                        ty: wgpu::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                }],
-                label: None,
+        log::info!("asdfasdgf");
+
+        let shadow_map =
+            texture::Texture::create_depth_texture(&device, &surface_config, "Shadow Map");
+        // let shadow_texture = device.create_texture(&wgpu::TextureDescriptor {
+        //     size: wgpu::Extent3d {
+        //         width: 1024,
+        //         height: 1024,
+        //         depth_or_array_layers: 10,
+        //     },
+        //     mip_level_count: 1,
+        //     sample_count: 1,
+        //     dimension: wgpu::TextureDimension::D2,
+        //     format: wgpu::TextureFormat::Depth32Float,
+        //     usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+        //     label: Some("Shadow texture"),
+        //     view_formats: &[],
+        // });
+        // For forward pass
+        // let shadow_view = shadow_texture.create_view(&wgpu::TextureViewDescriptor::default());
+
+        log::info!("alskjgsdl;kfgjs;dkjl");
+        // For light in shadow pass
+        // let light_shadow_map = shadow_texture.create_view(&wgpu::TextureViewDescriptor {
+        //     label: Some("Shadow Map"),
+        //     format: Some(wgpu::TextureFormat::Depth32Float),
+        //     dimension: Some(wgpu::TextureViewDimension::D2),
+        //     usage: None,
+        //     aspect: wgpu::TextureAspect::All,
+        //     base_mip_level: 0,
+        //     mip_level_count: None,
+        //     base_array_layer: 0 as u32,
+        //     array_layer_count: Some(1),
+        // });
+
+        // let shadow_map_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        //     label: Some("Shadow Map Buffer"),
+        //     contents: bytemuck::cast_slice(&[camera_uniform]),
+        //     usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        // });
+
+        // let shadow_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        //     entries: &[wgpu::BindGroupLayoutEntry {
+        //         binding: 0,
+        //         visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
+        //         ty: wgpu::BindingType::Buffer {
+        //             ty: wgpu::BufferBindingType::Uniform,
+        //             has_dynamic_offset: false,
+        //             min_binding_size: None,
+        //         },
+        //         count: None,
+        //     }],
+        //     label: None,
+        // });
+        // let shadow_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        //     layout: &shadow_bgl,
+        //     entries: &[wgpu::BindGroupEntry {
+        //         binding: 0,
+        //         resource: light_buffer.as_entire_binding(),
+        //     }],
+        //     label: None,
+        // });
+
+        log::info!("Pipeline setup!");
+        // New stuff goes above here!
+
+        log::info!("Pipeline/Globals setup!");
+        // let render_pipeline = {
+        //     let shader = wgpu::ShaderModuleDescriptor {
+        //         label: Some("Normal Shader"),
+        //         source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
+        //     };
+        //     create_render_pipeline(
+        //         &device,
+        //         &render_pipeline_layout,
+        //         surface_config.format,
+        //         Some(texture::Texture::DEPTH_FORMAT),
+        //         &[model::ModelVertex::desc(), InstanceRaw::desc()],
+        //         shader,
+        //         wgpu::PolygonMode::Fill,
+        //         Some("Normal Render Pipeline"),
+        //     )
+        // };
+        //
+        // //let fill_pipeline = render_pipeline(wgpu::PolygonMode::Fill);
+        // let wireframe_render_pipeline = if (device.features() & wgpu::Features::POLYGON_MODE_LINE)
+        //     == wgpu::Features::POLYGON_MODE_LINE
+        // {
+        //     Some({
+        //         let shader = wgpu::ShaderModuleDescriptor {
+        //             label: Some("Normal Shader"),
+        //             source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
+        //         };
+        //         create_render_pipeline(
+        //             &device,
+        //             &render_pipeline_layout,
+        //             surface_config.format,
+        //             Some(texture::Texture::DEPTH_FORMAT),
+        //             &[model::ModelVertex::desc(), InstanceRaw::desc()],
+        //             shader,
+        //             wgpu::PolygonMode::Line,
+        //             Some("Normal Render Pipeline"),
+        //         )
+        //     })
+        // } else {
+        //     None
+        // };
+
+        fn bgl_t(binding: u32) -> wgpu::BindGroupLayoutEntry {
+            wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            }
+        }
+        fn bge(binding: u32, resource: BindingResource<'_>) -> wgpu::BindGroupEntry {
+            wgpu::BindGroupEntry { binding, resource }
+        }
+
+        log::info!("Pipeline/Shadow setup!");
+
+        let shadow_pass = {
+            let camera_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Camera Buffer"),
+                size: size_of::<camera::CameraUniform>() as wgpu::BufferAddress,
+                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            });
+            let light_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Light VB"),
+                size: size_of::<CameraUniform>() as wgpu::BufferAddress,
+                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
             });
 
-        let light_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            layout: &light_bind_group_layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: light_buffer.as_entire_binding(),
-            }],
-            label: None,
-        });
+            let bind_group_layout =
+                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                    label: None,
+                    entries: &[
+                        // Camera
+                        bgl_t(0),
+                        // Light position
+                        bgl_t(1),
+                    ],
+                });
 
-        // New stuff goes above here!
-        let render_pipeline_layout =
-            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                label: Some("Render Pipeline Layout"),
-                bind_group_layouts: &[
-                    &texture_bind_group_layout,
-                    &camera_bind_group_layout,
-                    &light_bind_group_layout,
+            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: None,
+                layout: &bind_group_layout,
+                entries: &[
+                    bge(0, camera_buffer.as_entire_binding()),
+                    bge(1, light_buffer.as_entire_binding()),
                 ],
+            });
+
+            let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: Some("Shadow Pipeline Layout"),
+                bind_group_layouts: &[&bind_group_layout],
                 push_constant_ranges: &[],
             });
 
-        let render_pipeline = {
             let shader = wgpu::ShaderModuleDescriptor {
-                label: Some("Normal Shader"),
-                source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
+                label: Some("Shadow Shader"),
+                source: wgpu::ShaderSource::Wgsl(include_str!("shadows.wgsl").into()),
             };
-            create_render_pipeline(
+
+            let shader = device.create_shader_module(shader);
+
+            let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some("Shadows Render Pipeline"),
+                layout: Some(&pipeline_layout),
+                vertex: wgpu::VertexState {
+                    module: &shader,
+                    entry_point: Some("vs_main"),
+                    buffers: &[model::ModelVertex::desc(), InstanceRaw::desc()],
+                    compilation_options: Default::default(),
+                },
+                fragment: None,
+                primitive: wgpu::PrimitiveState {
+                    topology: wgpu::PrimitiveTopology::TriangleList,
+                    strip_index_format: None,
+                    front_face: wgpu::FrontFace::Ccw,
+                    cull_mode: Some(wgpu::Face::Back),
+                    // Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
+                    polygon_mode: wgpu::PolygonMode::Fill,
+                    // Requires Features::DEPTH_CLIP_CONTROL
+                    unclipped_depth: false,
+                    // Requires Features::CONSERVATIVE_RASTERIZATION
+                    conservative: false,
+                },
+                depth_stencil: Some(wgpu::DepthStencilState {
+                    format: wgpu::TextureFormat::Depth32Float,
+                    depth_write_enabled: true,
+                    depth_compare: wgpu::CompareFunction::Less,
+                    stencil: wgpu::StencilState::default(),
+                    bias: wgpu::DepthBiasState::default(),
+                }),
+                multisample: wgpu::MultisampleState {
+                    count: 1,
+                    mask: !0,
+                    alpha_to_coverage_enabled: false,
+                },
+                multiview: None,
+                cache: None,
+            });
+
+            Pass {
+                pipeline: OneOrTwo::One(pipeline),
+                bind_group,
+                uniform_bufs: vec![camera_buffer, light_buffer],
+            }
+        };
+
+        let forward_pass = {
+            let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Camera Buffer"),
+                contents: bytemuck::cast_slice(&[camera_uniform]),
+                usage: wgpu::BufferUsages::UNIFORM
+                    | wgpu::BufferUsages::COPY_DST
+                    | wgpu::BufferUsages::COPY_SRC,
+            });
+            let light_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Light VB"),
+                contents: bytemuck::cast_slice(&[light_uniform]),
+                usage: wgpu::BufferUsages::UNIFORM
+                    | wgpu::BufferUsages::COPY_DST
+                    | wgpu::BufferUsages::COPY_SRC,
+            });
+
+            let bind_group_layout =
+                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                    entries: &[
+                        // Camera positional Data
+                        bgl_t(0),
+                        // Light positional data
+                        bgl_t(1),
+                        // Shadowmap
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 2,
+                            visibility: wgpu::ShaderStages::FRAGMENT,
+                            ty: wgpu::BindingType::Texture {
+                                sample_type: wgpu::TextureSampleType::Depth,
+                                view_dimension: wgpu::TextureViewDimension::D2,
+                                multisampled: false,
+                            },
+                            count: None,
+                        },
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 3,
+                            visibility: wgpu::ShaderStages::FRAGMENT,
+                            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison),
+                            count: None,
+                        },
+                    ],
+                    label: None,
+                });
+
+            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                layout: &bind_group_layout,
+                entries: &[
+                    bge(0, camera_buffer.as_entire_binding()),
+                    bge(1, light_buffer.as_entire_binding()),
+                    bge(2, BindingResource::TextureView(&shadow_map.view)),
+                    bge(3, BindingResource::Sampler(&shadow_map.sampler)),
+                ],
+                label: None,
+            });
+
+            let render_pipeline = create_render_pipeline(
                 &device,
-                &render_pipeline_layout,
+                &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                    label: Some("Render Pipeline Layout"),
+                    bind_group_layouts: &[&texture_bind_group_layout, &bind_group_layout],
+                    push_constant_ranges: &[],
+                }),
                 surface_config.format,
                 Some(texture::Texture::DEPTH_FORMAT),
                 &[model::ModelVertex::desc(), InstanceRaw::desc()],
-                shader,
-                wgpu::PolygonMode::Fill,
-            )
-        };
-
-        //let fill_pipeline = render_pipeline(wgpu::PolygonMode::Fill);
-        let wireframe_render_pipeline = if (device.features() & wgpu::Features::POLYGON_MODE_LINE)
-            == wgpu::Features::POLYGON_MODE_LINE
-        {
-            Some({
-                let shader = wgpu::ShaderModuleDescriptor {
+                wgpu::ShaderModuleDescriptor {
                     label: Some("Normal Shader"),
                     source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
-                };
-                create_render_pipeline(
-                    &device,
-                    &render_pipeline_layout,
-                    surface_config.format,
-                    Some(texture::Texture::DEPTH_FORMAT),
-                    &[model::ModelVertex::desc(), InstanceRaw::desc()],
-                    shader,
-                    wgpu::PolygonMode::Line,
-                )
-            })
-        } else {
-            None
-        };
+                },
+                wgpu::PolygonMode::Fill,
+                Some("Normal Render Pipeline"),
+            );
 
-        let light_render_pipeline = {
-            let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                label: Some("Light Pipeline Layout"),
-                bind_group_layouts: &[&camera_bind_group_layout, &light_bind_group_layout],
-                push_constant_ranges: &[],
-            });
-            let shader = wgpu::ShaderModuleDescriptor {
-                label: Some("Light Shader"),
-                source: wgpu::ShaderSource::Wgsl(include_str!("light.wgsl").into()),
-            };
-            create_render_pipeline(
+            log::info!("Pipeline/Light setup!");
+            let light_render_pipeline = create_render_pipeline(
                 &device,
-                &layout,
+                &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                    label: Some("Light Pipeline Layout"),
+                    bind_group_layouts: &[&bind_group_layout],
+                    push_constant_ranges: &[],
+                }),
                 surface_config.format,
                 Some(texture::Texture::DEPTH_FORMAT),
-                &[model::ModelVertex::desc()],
-                shader,
+                &[model::ModelVertex::desc(), InstanceRaw::desc()],
+                wgpu::ShaderModuleDescriptor {
+                    label: Some("Light Shader"),
+                    source: wgpu::ShaderSource::Wgsl(include_str!("light.wgsl").into()),
+                },
                 wgpu::PolygonMode::Fill,
-            )
+                Some("Light Render Pipeline"),
+            );
+
+            Pass {
+                pipeline: OneOrTwo::Two(render_pipeline, light_render_pipeline),
+                bind_group,
+                uniform_bufs: vec![camera_buffer, light_buffer],
+            }
         };
+
+        log::debug!("Initialized!");
 
         Self {
             surface,
···
             surface_config,
             depth_texture,
             camera: camera_state,
+            shadow_pass,
+            forward_pass,
             interact: InteractState {
                 wireframe: false,
                 clear_color: wgpu::Color {
···
                     b: 0.3,
                     a: 1.0,
                 },
-            },
-            render_pipelines: RenderPipelines {
-                camera: render_pipeline,
-                camera_wireframe: wireframe_render_pipeline,
-                light: light_render_pipeline,
             },
             object: ObjectState {
                 model: obj_model,
···
                 remake: false,
             },
             light: LightState {
+                object: light,
                 uniform: light_uniform,
-                buffer: light_buffer,
-                bind_group: light_bind_group,
+                shadow_map,
             },
         }
     }
···
 
         self.surface_config.width = new_size.width;
         self.surface_config.height = new_size.height;
-        self.camera.positioning.aspect =
+        self.camera.object.aspect =
             self.surface_config.width as f32 / self.surface_config.height as f32;
         self.surface.configure(&self.device, &self.surface_config);
 
···
                         return None;
                     }
 
-                    let chunk_offset = IVec3::from(*coords).as_vec3() * (SPACE_BETWEEN * CHUNK_SIZE.0 as f32);
+                    let chunk_offset =
+                        IVec3::from(*coords).as_vec3() * (SPACE_BETWEEN * CHUNK_SIZE.0 as f32);
 
                     let mapping = |n| SPACE_BETWEEN * (n as f32 - CHUNK_SIZE.0 as f32 / 2.0);
                     let position = vec3(
···
     }
 
     pub fn update_instance_buf(&mut self, map: &WorldMap) {
-        let instances = Self::remake_instance_buf(&map);
+        let instances = Self::remake_instance_buf(map);
 
         let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
         let instance_buffer = self
···
                 label: Some("Render Encoder"),
             });
 
-        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Render Pass"),
-            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                view: &view,
-                resolve_target: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(self.interact.clear_color),
-                    store: wgpu::StoreOp::Store,
-                },
-            })],
-            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-                view: &self.depth_texture.view,
-                depth_ops: Some(wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(1.0),
-                    store: wgpu::StoreOp::Store,
+        log::debug!("Hi renderer!");
+
+        encoder.push_debug_group("Shadow pass");
+        use crate::gfx::model::DrawModel;
+
+        // Shadow-map Pass
+        {
+            let Pass {
+                pipeline,
+                bind_group,
+                uniform_bufs,
+            } = &mut self.shadow_pass;
+
+            encoder.copy_buffer_to_buffer(
+                &self.forward_pass.uniform_bufs[0],
+                0,
+                &uniform_bufs[0],
+                0,
+                size_of::<CameraUniform>() as wgpu::BufferAddress,
+            );
+            encoder.copy_buffer_to_buffer(
+                &self.forward_pass.uniform_bufs[1],
+                0,
+                &uniform_bufs[1],
+                0,
+                size_of::<CameraUniform>() as wgpu::BufferAddress,
+            );
+
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Shadow Render Pass"),
+                color_attachments: &[],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &self.light.shadow_map.view, // Shadow map written here
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(1.0),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
+                }),
+                occlusion_query_set: None,
+                timestamp_writes: None,
+            });
+            render_pass.set_pipeline(pipeline.one());
+            render_pass.set_vertex_buffer(1, self.object.instance_buffer.slice(..));
+
+            render_pass.draw_light_model_instanced(
+                &self.object.model,
+                0..self.object.instances.len() as u32,
+                &[bind_group],
+            );
+
+            drop(render_pass);
+        }
+
+        encoder.pop_debug_group();
+
+        encoder.push_debug_group("Forward pass");
+
+        {
+            let Pass {
+                pipeline,
+                bind_group,
+                uniform_bufs,
+            } = &mut self.forward_pass;
+
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Forward Render Pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(self.interact.clear_color),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &self.depth_texture.view,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(1.0),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
                 }),
-                stencil_ops: None,
-            }),
-            occlusion_query_set: None,
-            timestamp_writes: None,
-        });
+                occlusion_query_set: None,
+                timestamp_writes: None,
+            });
 
-        render_pass.set_vertex_buffer(1, self.object.instance_buffer.slice(..));
+            render_pass.set_vertex_buffer(1, self.object.instance_buffer.slice(..));
 
-        use crate::gfx::model::DrawLight;
-        render_pass.set_pipeline(&self.render_pipelines.light);
-        render_pass.draw_light_model(
-            &self.object.model,
-            &self.camera.bind_group,
-            &self.light.bind_group,
-        );
+            // use crate::gfx::model::DrawLight;
+            // render_pass.set_pipeline(pipeline.two().1);
+            // render_pass.draw_light_model(
+            //     &self.object.model,
+            //     &self.camera.bind_group,
+            //     &self.light.bind_group,
+            // );
 
-        use crate::gfx::model::DrawModel;
-        render_pass.set_pipeline(
-            self.interact
-                .wireframe
-                .then_some(self.render_pipelines.camera_wireframe.as_ref())
-                .flatten()
-                .unwrap_or(&self.render_pipelines.camera),
-        );
+            // render_pass.set_pipeline(&self.render_pipelines.cam);
+            // render_pass.draw_model_instanced(
+            //     &self.object.model,
+            //     0..self.object.instances.len() as u32,
+            //     &self.camera.bind_group,
+            //     &self.light.bind_group,
+            // );
 
-        render_pass.draw_model_instanced(
-            &self.object.model,
-            0..self.object.instances.len() as u32,
-            &self.camera.bind_group,
-            &self.light.bind_group,
-        );
+            /*            render_pass.set_pipeline(
+                self.interact
+                    .wireframe
+                    .then_some(self.render_pipelines.camera_wireframe.as_ref())
+                    .flatten()
+                    .unwrap_or(&self.render_pipelines.camera),
+            );*/
+
+            render_pass.set_pipeline(pipeline.two().0);
+
+            render_pass.draw_model_instanced(
+                &self.object.model,
+                0..self.object.instances.len() as u32,
+                &[bind_group],
+            );
+
+            drop(render_pass);
+        }
 
         // drop render pass before we submit to drop the mut borrow on encoder
-        drop(render_pass);
+
+        encoder.pop_debug_group();
 
         // Layer EGUI on top of frame!
 
···
     pub fn update(&mut self, world: &mut World) {
         self.camera
             .controller
-            .update_camera(&mut self.camera.positioning);
-        self.camera
-            .uniform
-            .update_view_proj(&self.camera.positioning);
+            .update_camera(&mut self.camera.object);
+
+        // dbg
+        //self.camera.object.eye = self.light.uniform.view_pos;
+
+        self.camera.uniform.update_view_proj(&self.camera.object);
         self.queue.write_buffer(
-            &self.camera.buffer,
+            &self.forward_pass.uniform_bufs[0],
             0,
             bytemuck::cast_slice(&[self.camera.uniform]),
         );
 
-        let old_position: Vec3 = self.light.uniform.position;
-        self.light.uniform.position =
-            Quat::from_axis_angle(vec3(0.0, 1.0, 0.0), 0.01) * old_position;
+        self.light.object.eye =
+            Quat::from_axis_angle(vec3(0.0, 1.0, 0.0), 0.01) * self.light.object.eye;
+        self.light.uniform.update_view_proj(&self.light.object);
+
+        // let old_position: Vec3 = self.light.uniform.view_pos;
+        // self.light.uniform.view_pos =
+        //     Quat::from_axis_angle(vec3(0.0, 1.0, 0.0), 0.01) * old_position;
+        // self.light
+        //     .uniform
+        //     .update_view_proj(self.surface_config.width as f32 / self.surface_config.height as f32);
+
         self.queue.write_buffer(
-            &self.light.buffer,
+            &self.forward_pass.uniform_bufs[1],
             0,
             bytemuck::cast_slice(&[self.light.uniform]),
         );

src/gfx/camera.rs

···
 #[repr(C)]
 #[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct CameraUniform {
-    view_position: Vec4,
-    view_proj: Mat4,
+    pub view_position: Vec4,
+    pub view_proj: Mat4,
 }
 
 impl CameraUniform {

src/gfx/light.rs

···
+use std::f32::consts::PI;
+
+use crate::gfx::camera::Camera;
+use glam::{vec3, Mat4, Vec3, Vec4};
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub(crate) struct LightUniform {
+    pub view_pos: Vec3,
+    _pad: u32,
+    pub view_proj: Mat4,
+    pub color: Vec3,
+    _pad2: u32,
+}
+impl LightUniform {
+    pub fn new(position: Vec3, color: Vec3) -> LightUniform {
+        LightUniform {
+            view_pos: position,
+            view_proj: {
+                let view = Mat4::look_at_rh(position, Vec3::ZERO, Vec3::Y);
+                let proj = Mat4::perspective_rh(PI / 2., 1.0, 0.1, 1000.0);
+
+                view * proj
+            },
+            color,
+            _pad: 0,
+            _pad2: 0,
+        }
+    }
+
+    pub fn update_view_proj(&mut self, aspect_ratio: f32) {
+        self.view_proj = {
+            let view = Mat4::look_at_rh(vec3(50., 20., 50.), Vec3::ZERO, Vec3::Y);
+            let proj = Mat4::perspective_rh(PI / 2., aspect_ratio, 0.1, 1000.0);
+
+            view * proj
+        };
+    }
+
+    // pub fn build_view_projection_matrix(&self) -> Mat4 {
+    // let view = Mat4::look_at_rh(self.eye, self.target, self.up);
+    // let proj = Mat4::perspective_rh(self.fovy, self.aspect, self.znear, self.zfar);
+
+    //     proj * view
+    // }
+}

src/gfx/model.rs

···
-use std::ops::Range;
-
 use super::texture;
+use std::ops::Range;
+use wasm_bindgen::__rt::__wbindgen_exn_store;
 
 pub trait Vertex {
     fn desc() -> wgpu::VertexBufferLayout<'static>;
···
         &mut self,
         mesh: &'a Mesh,
         material: &'a Material,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
+        bind_groups: &[&'a wgpu::BindGroup],
     );
     fn draw_mesh_instanced(
         &mut self,
         mesh: &'a Mesh,
         material: &'a Material,
         instances: Range<u32>,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
-    );
-    fn draw_model(
-        &mut self,
-        model: &'a Model,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
+        bind_groups: &[&'a wgpu::BindGroup],
     );
+    fn draw_model(&mut self, model: &'a Model, bind_groups: &[&'a wgpu::BindGroup]);
     fn draw_model_instanced(
         &mut self,
         model: &'a Model,
         instances: Range<u32>,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
+        bind_groups: &[&'a wgpu::BindGroup],
     );
 }
 
···
         &mut self,
         mesh: &'b Mesh,
         material: &'b Material,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
+        bind_groups: &[&'b wgpu::BindGroup],
     ) {
-        self.draw_mesh_instanced(mesh, material, 0..1, camera_bind_group, light_bind_group);
+        self.draw_mesh_instanced(mesh, material, 0..1, bind_groups);
     }
 
     fn draw_mesh_instanced(
···
         mesh: &'b Mesh,
         material: &'a Material,
         instances: Range<u32>,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
+        bind_groups: &[&'b wgpu::BindGroup],
     ) {
         self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
         self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
         self.set_bind_group(0, &material.bind_group, &[]);
-        self.set_bind_group(1, camera_bind_group, &[]);
-        self.set_bind_group(2, light_bind_group, &[]);
+        for (i, group) in bind_groups.iter().enumerate() {
+            self.set_bind_group((i + 1) as u32, *group, &[]);
+        }
         self.draw_indexed(0..mesh.num_elements, 0, instances);
     }
-    fn draw_model(
-        &mut self,
-        model: &'b Model,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
-    ) {
-        self.draw_model_instanced(model, 0..1, camera_bind_group, light_bind_group);
+    fn draw_model(&mut self, model: &'b Model, bind_groups: &[&'b wgpu::BindGroup]) {
+        self.draw_model_instanced(model, 0..1, bind_groups);
     }
 
     fn draw_model_instanced(
         &mut self,
         model: &'b Model,
         instances: Range<u32>,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
+        bind_groups: &[&'b wgpu::BindGroup],
     ) {
         for mesh in &model.meshes {
             let material = &model.materials[mesh.material];
-            self.draw_mesh_instanced(
-                mesh,
-                material,
-                instances.clone(),
-                camera_bind_group,
-                light_bind_group,
-            );
+            self.draw_mesh_instanced(mesh, material, instances.clone(), bind_groups);
         }
     }
 }
 
 pub trait DrawLight<'a> {
-    fn draw_light_mesh(
-        &mut self,
-        mesh: &'a Mesh,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
-    );
+    fn draw_light_mesh(&mut self, mesh: &'a Mesh, bind_groups: &[&'a wgpu::BindGroup]);
     fn draw_light_mesh_instanced(
         &mut self,
         mesh: &'a Mesh,
         instances: Range<u32>,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
+        bind_groups: &[&'a wgpu::BindGroup],
     );
 
-    fn draw_light_model(
-        &mut self,
-        model: &'a Model,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
-    );
+    fn draw_light_model(&mut self, model: &'a Model, bind_groups: &[&'a wgpu::BindGroup]);
     fn draw_light_model_instanced(
         &mut self,
         model: &'a Model,
         instances: Range<u32>,
-        camera_bind_group: &'a wgpu::BindGroup,
-        light_bind_group: &'a wgpu::BindGroup,
+        bind_groups: &[&'a wgpu::BindGroup],
     );
 }
 
···
 where
     'b: 'a,
 {
-    fn draw_light_mesh(
-        &mut self,
-        mesh: &'b Mesh,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
-    ) {
-        self.draw_light_mesh_instanced(mesh, 0..1, camera_bind_group, light_bind_group);
+    fn draw_light_mesh(&mut self, mesh: &'b Mesh, bind_groups: &[&'b wgpu::BindGroup]) {
+        self.draw_light_mesh_instanced(mesh, 0..1, bind_groups);
     }
 
     fn draw_light_mesh_instanced(
         &mut self,
         mesh: &'b Mesh,
         instances: Range<u32>,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
+        bind_groups: &[&'b wgpu::BindGroup],
     ) {
         self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
         self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
-        self.set_bind_group(0, camera_bind_group, &[]);
-        self.set_bind_group(1, light_bind_group, &[]);
+        for (i, group) in bind_groups.iter().enumerate() {
+            self.set_bind_group(i as u32, *group, &[]);
+        }
         self.draw_indexed(0..mesh.num_elements, 0, instances);
     }
 
-    fn draw_light_model(
-        &mut self,
-        model: &'b Model,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
-    ) {
-        self.draw_light_model_instanced(model, 0..1, camera_bind_group, light_bind_group);
+    fn draw_light_model(&mut self, model: &'b Model, bind_groups: &[&'b wgpu::BindGroup]) {
+        self.draw_light_model_instanced(model, 0..1, bind_groups);
     }
     fn draw_light_model_instanced(
         &mut self,
         model: &'b Model,
         instances: Range<u32>,
-        camera_bind_group: &'b wgpu::BindGroup,
-        light_bind_group: &'b wgpu::BindGroup,
+        bind_groups: &[&'b wgpu::BindGroup],
     ) {
         for mesh in &model.meshes {
-            self.draw_light_mesh_instanced(
-                mesh,
-                instances.clone(),
-                camera_bind_group,
-                light_bind_group,
-            );
+            self.draw_light_mesh_instanced(mesh, instances.clone(), bind_groups);
         }
     }
 }

src/gui.rs

···
 use glam::{ivec2, ivec3, IVec2};
 use winit::window::Window;
 
-use crate::{gfx::Gfx, world::map::{chunk_scramble_dispatch, ChunkScramble}, world::World};
+use crate::{
+    gfx::Gfx,
+    world::map::{chunk_scramble_dispatch, ChunkScramble},
+    world::World,
+};
 
 pub struct EguiRenderer {
     state: egui_winit::State,
···
             renderer,
             frame_started: false,
             scale_factor: 1.0,
-            chunk_influence: (0,0)
+            chunk_influence: (0, 0),
         }
     }
 
     pub fn handle_input(&mut self, window: &Window, event: &winit::event::WindowEvent) -> bool {
-        let EventResponse {consumed, ..} = self.state.on_window_event(window, event);
+        let EventResponse { consumed, .. } = self.state.on_window_event(window, event);
         consumed
     }
 
···
         }
 
         #[cfg(not(target_arch = "wasm32"))]
-        self.ctx().set_pixels_per_point(screen_descriptor.pixels_per_point);
+        self.ctx()
+            .set_pixels_per_point(screen_descriptor.pixels_per_point);
 
         let full_output = self.ctx().end_pass();
 
···
             .tessellate(full_output.shapes, self.ctx().pixels_per_point());
 
         #[cfg(target_arch = "wasm32")]
-        let tris = self
-            .ctx()
-            .tessellate(full_output.shapes, 1.0);
+        let tris = self.ctx().tessellate(full_output.shapes, 1.0);
 
         for (id, image_delta) in &full_output.textures_delta.set {
             self.renderer
···
 
                 ui.separator();
 
-                ui.add(egui::Slider::new(&mut gfx.camera.controller.speed, 0.1..=10.0).text("Cam Speed"));
+                ui.add(
+                    egui::Slider::new(&mut gfx.camera.controller.speed, 0.1..=10.0)
+                        .text("Cam Speed"),
+                );
 
                 ui.separator();
 
-                ui.label(format!("The camera is pointing at {:?}", gfx.camera.positioning.target));
-                ui.add(egui::Slider::new(&mut gfx.camera.positioning.eye.x, -500.0..=500.0).text("Cam X"));
-                ui.add(egui::Slider::new(&mut gfx.camera.positioning.eye.y, -500.0..=500.0).text("Cam Y"));
-                ui.add(egui::Slider::new(&mut gfx.camera.positioning.eye.z, -500.0..=500.0).text("Cam Z"));
+                ui.label(format!(
+                    "The camera is pointing at {:?}",
+                    gfx.camera.object.target
+                ));
+                ui.add(
+                    egui::Slider::new(&mut gfx.camera.object.eye.x, -500.0..=500.0).text("Cam X"),
+                );
+                ui.add(
+                    egui::Slider::new(&mut gfx.camera.object.eye.y, -500.0..=500.0).text("Cam Y"),
+                );
+                ui.add(
+                    egui::Slider::new(&mut gfx.camera.object.eye.z, -500.0..=500.0).text("Cam Z"),
+                );
 
                 ui.separator();
                 ui.horizontal(|ui| {
···
                 });
 
                 ui.horizontal(|ui| {
-                    let pos = ivec3(chunk_x,0,chunk_z);
+                    let pos = ivec3(chunk_x, 0, chunk_z);
 
                     if ui.button("Random").clicked() {
                         let c = chunk_scramble_dispatch(ChunkScramble::Random)(pos);
···
                 });
 
                 ui.separator();
-
 
                 ui.horizontal(|ui| {
-
                     if ui.button("Save").clicked() {
                         world.save().unwrap();
                     }
···
                         *world = World::load().unwrap();
                         gfx.object.remake = true;
                     }
-
                 });
-
-
             });
 
         self.scale_factor = scale_factor;
         self.chunk_influence = (chunk_x, chunk_z);
     }
-}
+}

src/lib.rs

···
         use std::mem;
 
         wgpu::VertexBufferLayout {
-            array_stride: mem::size_of::<InstanceRaw>() as wgpu::BufferAddress,
+            array_stride: size_of::<InstanceRaw>() as wgpu::BufferAddress,
             step_mode: wgpu::VertexStepMode::Instance,
             attributes: &[
                 wgpu::VertexAttribute {
···
                     format: wgpu::VertexFormat::Float32x4,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 4]>() as wgpu::BufferAddress,
                     shader_location: 6,
                     format: wgpu::VertexFormat::Float32x4,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 8]>() as wgpu::BufferAddress,
                     shader_location: 7,
                     format: wgpu::VertexFormat::Float32x4,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 12]>() as wgpu::BufferAddress,
                     shader_location: 8,
                     format: wgpu::VertexFormat::Float32x4,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 16]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 16]>() as wgpu::BufferAddress,
                     shader_location: 9,
                     format: wgpu::VertexFormat::Float32x3,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 19]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 19]>() as wgpu::BufferAddress,
                     shader_location: 10,
                     format: wgpu::VertexFormat::Float32x3,
                 },
                 wgpu::VertexAttribute {
-                    offset: mem::size_of::<[f32; 22]>() as wgpu::BufferAddress,
+                    offset: size_of::<[f32; 22]>() as wgpu::BufferAddress,
                     shader_location: 11,
                     format: wgpu::VertexFormat::Float32x3,
                 },
···
             console_log::init_with_level(log::Level::Debug).expect("Couldn't initialize logger");
         } else {
             //env_logger::init();
-            env_logger::builder().filter_level(log::LevelFilter::Info).init();
+            env_logger::builder().filter_level(log::LevelFilter::Warn).init();
         }
     }
 }

src/light.wgsl

···
 @group(0) @binding(0)
 var<uniform> camera: Camera;
 
-struct Light {
-    position: vec3<f32>,
-    color: vec3<f32>,
-}
-
-@group(1) @binding(0)
-var<uniform> light: Light;
+@group(0) @binding(1)
+var<uniform> light: Camera;
 
 struct VertexInput {
     @location(0) position: vec3<f32>,
···
     model: VertexInput,
 ) -> VertexOutput {
     let scale = 0.75;
+    let light_color = vec3<f32>(1.0, 1.0, 1.0);
     var out: VertexOutput;
-    out.clip_position = camera.view_proj * vec4<f32>(model.position * scale + light.position, 1.0);
-    out.color = light.color;
+    out.clip_position = camera.view_proj * vec4<f32>(model.position * scale + light.view_pos.xyz, 1.0);
+    out.color = light_color;
     return out;
 }
 

src/shader.wgsl

···
 @group(1) @binding(0)
 var<uniform> camera: Camera;
 
+@group(1) @binding(1)
+var<uniform> light: Camera;
 
-struct Light {
-    position: vec3<f32>,
-    color: vec3<f32>,
-}
-@group(2) @binding(0)
-var<uniform> light: Light;
 
 struct VertexInput {
     @location(0) position: vec3<f32>,
···
 @group(0) @binding(1)
 var s_diffuse: sampler;
 
+@group(1) @binding(2)
+var t_shadow: texture_depth_2d;
+@group(1) @binding(3)
+var s_shadow: sampler_comparison;
+
+
+fn fetch_shadow(homogeneous_coords: vec4<f32>) -> f32 {
+    if (homogeneous_coords.w <= 0.0) {
+        return 1.0;
+    }
+    // compensate for the Y-flip difference between the NDC and texture coordinates
+    let flip_correction = vec2<f32>(0.5, -0.5);
+    // compute texture coordinates for shadow lookup
+    let proj_correction = 1.0 / homogeneous_coords.w;
+    let light_local = homogeneous_coords.xy * flip_correction * proj_correction + vec2<f32>(0.5, 0.5);
+    // do the lookup, using HW PCF and comparison
+    return textureSampleCompareLevel(t_shadow, s_shadow, light_local, homogeneous_coords.z * proj_correction);
+}
+
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let light_color = vec3<f32>(1.0, 1.0, 1.0);
+
     let object_color: vec4<f32> = textureSample(t_diffuse, s_diffuse, in.tex_coords);
 
     let ambient_strength = 0.1;
-    let ambient_color = light.color * ambient_strength;
+    let ambient_color = light_color * ambient_strength;
 
-    let light_dir = normalize(light.position - in.world_position);
+    let light_dir = normalize(light.view_pos.xyz - in.world_position.xyz);
     let diffuse_strength = max(dot(in.world_normal, light_dir), 0.0);
-    let diffuse_color = light.color * diffuse_strength;
+    let diffuse_color = light_color * diffuse_strength;
 
-    let view_dir = normalize(camera.view_pos.xyz - in.world_position);
+    let view_dir = normalize(camera.view_pos.xyz - in.world_position.xyz);
     let half_dir = normalize(view_dir + light_dir);
 
     let specular_strength = pow(max(dot(in.world_normal, half_dir), 0.0), 32.0);
-    let specular_color = specular_strength * light.color;
+    let specular_color = specular_strength * light_color;
 
-    let result = (ambient_color + diffuse_color + specular_color) * object_color.xyz;
+    let shadow = fetch_shadow(light.view_proj * vec4<f32>(in.world_position, 1.0));
+
+    let result = (ambient_color + diffuse_color + specular_color) * shadow * object_color.xyz;
 
     return vec4<f32>(result, object_color.a);
 }

src/shadows.wgsl

···
+// Vertex shader
+
+// TODO CITE
+// Somewhat referenced from:
+// https://github.com/gfx-rs/wgpu/blob/trunk/examples/features/src/shadow/shader.wgsl
+
+struct InstanceInput {
+    @location(5) model_matrix_0: vec4<f32>,
+    @location(6) model_matrix_1: vec4<f32>,
+    @location(7) model_matrix_2: vec4<f32>,
+    @location(8) model_matrix_3: vec4<f32>,
+
+    @location(9) normal_matrix_0: vec3<f32>,
+    @location(10) normal_matrix_1: vec3<f32>,
+    @location(11) normal_matrix_2: vec3<f32>,
+};
+
+struct Camera {
+    view_pos: vec4<f32>,
+    view_proj: mat4x4<f32>,
+}
+@group(0) @binding(0)
+var<uniform> camera: Camera;
+
+@group(0) @binding(1)
+var<uniform> light: Camera;
+
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+    @location(1) tex_coords: vec2<f32>,
+    @location(2) normal: vec3<f32>,
+}
+
+@vertex
+fn vs_main(
+    model: VertexInput,
+    instance: InstanceInput,
+) -> @builtin(position) vec4<f32> {
+
+    let model_matrix = mat4x4<f32> (
+        instance.model_matrix_0,
+        instance.model_matrix_1,
+        instance.model_matrix_2,
+        instance.model_matrix_3,
+    );
+
+    let world_position: vec4<f32> = model_matrix * vec4<f32>(model.position, 1.0);
+
+    return light.view_proj * world_position;
+}

src/world/map.rs

···
 use bincode::{Decode, Encode};
 use glam::{ivec2, ivec3, IVec2, IVec3};
 use itertools::Itertools;
-use rand::{distr::{Distribution, StandardUniform}, Rng};
+use rand::{
+    distr::{Distribution, StandardUniform},
+    Rng,
+};
 use std::collections::HashMap;
 
 // I have arbitrarily decided that this is (x,z,y) where +y is up.
···
     }
 }
 
-
 fn new_chunk(world_pos: IVec3) -> Chunk {
     let blocks = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2)
         .map(|(x, z, y)| {
-            let tile_pos = ivec3(x as _,y as _,z as _);
+            let tile_pos = ivec3(x as _, y as _, z as _);
 
             // let (xf, zf, yf) = (
             //     (x as i32 + (world_x * CHUNK_SIZE.0 as i32)) as f32,
···
             // );
             let tile_pos_worldspace = (tile_pos + (world_pos * CHUNK_SIZE.0 as i32)).as_vec3();
 
-            let sines = f32::sin(tile_pos_worldspace.x * 0.1) + f32::sin(tile_pos_worldspace.z * 0.1);
+            let sines =
+                f32::sin(tile_pos_worldspace.x * 0.1) + f32::sin(tile_pos_worldspace.z * 0.1);
 
             // Pretty arbitrary numbers! Just trying to get something interesting
-            let n = (((sines / 4. + 0.5) * CHUNK_SIZE.2 as f32).round() as i32) <= tile_pos_worldspace.y as _;
+            let n = (((sines / 4. + 0.5) * CHUNK_SIZE.2 as f32).round() as i32)
+                <= tile_pos_worldspace.y as _;
 
             if n {
                 Block::Brick
···
     let mut chunks = HashMap::new();
 
     for (x, z) in itertools::iproduct!(iter.clone(), iter) {
-        let p = ivec3(x,0,z);
+        let p = ivec3(x, 0, z);
         chunks.insert(p.into(), new_chunk(p));
         chunks.insert(p.with_y(1).into(), new_chunk(p.with_y(1)));
-
     }
 
     WorldMap { chunks }
···
                 .collect_array()
                 .unwrap(),
         },
-        C::Random => |_| {
-            Chunk {
-                blocks: rand::rng().random()
-            }
-        }
+        C::Random => |_| Chunk {
+            blocks: rand::rng().random(),
+        },
     }
 }
 
···
     Normal,
     Inverse,
     Random,
-}
+}