Shadowmap tweaking

src/gfx.rs

···
 pub struct InteractState {
     pub clear_color: wgpu::Color,
     pub wireframe: bool,
+    pub shadows: bool,
 }
 pub struct ObjectState {
     pub model: model::Model,
···
         surface.configure(&device, &surface_config);
 
         let depth_texture =
-            texture::Texture::create_depth_texture(&device, &surface_config, "depth_texture");
+            texture::Texture::create_depth_texture(&device, &surface_config, None, "depth_texture");
 
         let texture_bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
···
 
         log::info!("Light setup!");
         let light = camera::Camera {
-            eye: vec3(90., 40., 90.),
+            eye: vec3(0., 300., 0.),
             target: Vec3::ZERO,
             up: Vec3::Y,
             aspect: surface_config.width as f32 / surface_config.height as f32,
···
 
         log::info!("asdfasdgf");
 
-        let shadow_map =
-            texture::Texture::create_depth_texture(&device, &surface_config, "Shadow Map");
+        let shadow_map = texture::Texture::create_depth_texture(
+            &device,
+            &surface_config,
+            Some((1000, 1000)),
+            "Shadow Map",
+        );
         // let shadow_texture = device.create_texture(&wgpu::TextureDescriptor {
         //     size: wgpu::Extent3d {
         //         width: 1024,
···
                     topology: wgpu::PrimitiveTopology::TriangleList,
                     strip_index_format: None,
                     front_face: wgpu::FrontFace::Ccw,
-                    cull_mode: Some(wgpu::Face::Back),
+                    cull_mode: Some(wgpu::Face::Front),
                     // Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
                     polygon_mode: wgpu::PolygonMode::Fill,
                     // Requires Features::DEPTH_CLIP_CONTROL
···
                     b: 0.3,
                     a: 1.0,
                 },
+                shadows: true,
             },
             object: ObjectState {
                 model: obj_model,
···
         self.depth_texture = texture::Texture::create_depth_texture(
             &self.device,
             &self.surface_config,
+            None,
             "depth_texture",
         );
     }
···
         use crate::gfx::model::DrawModel;
 
         // Shadow-map Pass
-        {
+        if self.interact.shadows {
             let Pass {
                 pipeline,
                 bind_group,
···
 
             render_pass.set_vertex_buffer(1, self.object.instance_buffer.slice(..));
 
-            // use crate::gfx::model::DrawLight;
+            use crate::gfx::model::DrawLight;
             // render_pass.set_pipeline(pipeline.two().1);
             // render_pass.draw_light_model(
             //     &self.object.model,
···
                     .unwrap_or(&self.render_pipelines.camera),
             );*/
 
+            render_pass.set_pipeline(pipeline.two().1);
+
+            render_pass.draw_light_model(&self.object.model, &[bind_group]);
+
             render_pass.set_pipeline(pipeline.two().0);
 
             render_pass.draw_model_instanced(
···
         );
 
         self.light.object.eye =
-            Quat::from_axis_angle(vec3(0.0, 1.0, 0.0), 0.01) * self.light.object.eye;
+            Quat::from_axis_angle(vec3(0.0, 0.0, 1.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;

src/gfx/texture.rs

···
     pub fn create_depth_texture(
         device: &wgpu::Device,
         config: &wgpu::SurfaceConfiguration,
+        size_override: Option<(u32, u32)>,
         label: &str,
     ) -> Self {
         let size = wgpu::Extent3d {
-            width: config.width.max(1),
-            height: config.height.max(1),
+            width: size_override
+                .map(|(w, _h)| w)
+                .unwrap_or(config.width.max(1)),
+            height: size_override
+                .map(|(_w, h)| h)
+                .unwrap_or(config.height.max(1)),
             depth_or_array_layers: 1,
         };
 

src/gui.rs

···
                 ui.add(
                     egui::Slider::new(&mut gfx.camera.object.eye.z, -500.0..=500.0).text("Cam Z"),
                 );
+                ui.separator();
+
+                ui.checkbox(
+                    &mut gfx.interact.shadows,
+                    "Light shadowing (via shadow-maps)",
+                );
 
                 ui.separator();
                 ui.horizontal(|ui| {

src/light.wgsl

···
 fn vs_main(
     model: VertexInput,
 ) -> VertexOutput {
-    let scale = 0.75;
+    let scale = 10.0;
     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.view_pos.xyz, 1.0);

src/shader.wgsl

···
 @group(1) @binding(3)
 var s_shadow: sampler_comparison;
 
-
+// TODO CITE: wgpu/examples/shadow
 fn fetch_shadow(homogeneous_coords: vec4<f32>) -> f32 {
     if (homogeneous_coords.w <= 0.0) {
         return 1.0;
···
 }
 
 @fragment
-fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+fn fs_main(in: VertexOutput, @builtin(front_facing) face: bool) -> @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 view_dir = normalize(camera.view_pos.xyz - in.world_position.xyz);
     let half_dir = normalize(view_dir + light_dir);
+
+    let shadow = fetch_shadow(light.view_proj * vec4<f32>(in.world_position, 1.0));
+
 
     let specular_strength = pow(max(dot(in.world_normal, half_dir), 0.0), 32.0);
-    let specular_color = specular_strength * light_color;
 
-    let shadow = fetch_shadow(light.view_proj * vec4<f32>(in.world_position, 1.0));
+    // Disable specular effects in shadow
+    let specular_color = specular_strength * light_color * shadow;
 
-    let result = (ambient_color + diffuse_color + specular_color) * shadow * object_color.xyz;
+//    let result = (ambient_color + diffuse_color + specular_color) * shadow * object_color.xyz;
+    let result = (ambient_color + diffuse_color + specular_color) * (shadow * 0.5 + 0.5);
 
     return vec4<f32>(result, object_color.a);
 }