From 1bb45ec31be60c66034c7faefcd6a6e489c2ed10 Mon Sep 17 00:00:00 2001
From: Piotrek <piotrek54pl@gmail.com>
Date: Sun, 25 Apr 2021 16:22:24 +0200
Subject: [PATCH] renamed brick to block, world gen stuff in separate file

---
 src/app/mod.rs                                |  56 +--------
 src/app/world_gen.rs                          |  44 +++++++-
 .../buffers/{brick_buffer.rs => blocks.rs}    |  65 +++++------
 .../{material_buffer.rs => materials.rs}      |  25 +++--
 src/renderer/buffers/mod.rs                   |  30 ++---
 .../buffers/{node_buffer.rs => nodes.rs}      |   4 +-
 .../buffers/{raster_buffer.rs => raster.rs}   |   4 +-
 .../buffers/{uniform_buffer.rs => uniform.rs} |   6 +-
 src/renderer/mod.rs                           | 106 ++++++------------
 src/renderer/passes/mod.rs                    |   3 +
 src/renderer/passes/raytrace.rs               |  57 ++++++++++
 src/shaders/bin/shader.frag.spv               | Bin 15176 -> 15660 bytes
 src/shaders/shader.frag                       |  11 +-
 src/shaders/shading.cginc                     |  18 +--
 src/shaders/shapes.cginc                      |  14 ---
 15 files changed, 223 insertions(+), 220 deletions(-)
 rename src/renderer/buffers/{brick_buffer.rs => blocks.rs} (62%)
 rename src/renderer/buffers/{material_buffer.rs => materials.rs} (77%)
 rename src/renderer/buffers/{node_buffer.rs => nodes.rs} (98%)
 rename src/renderer/buffers/{raster_buffer.rs => raster.rs} (97%)
 rename src/renderer/buffers/{uniform_buffer.rs => uniform.rs} (95%)
 create mode 100644 src/renderer/passes/mod.rs
 create mode 100644 src/renderer/passes/raytrace.rs
 delete mode 100644 src/shaders/shapes.cginc

diff --git a/src/app/mod.rs b/src/app/mod.rs
index 4c7fc75..9ed1847 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -2,8 +2,9 @@ use winit::{
     event::{Event, WindowEvent, KeyboardInput, ElementState, VirtualKeyCode, MouseButton},
     window::Window
 };
+use cgmath::Point3;
 use std::sync::Arc;
-use rand::Rng;
+
 
 mod camera_controller; use camera_controller::CameraController;
 mod world_gen; use world_gen::WorldGen;
@@ -23,61 +24,16 @@ impl App {
         let camera_controller = CameraController::new();
         let mut world_gen = WorldGen::new();
 
-
-        // let start = std::time::Instant::now();
-        // for x in 0..128 {
-        //     for z in 0..128 {
-        //         // Dirt
-        //         for y in 0..31 {
-        //             renderer.set_voxel(x, y, z, 1);
-        //         }
-        //         // Grass
-        //         renderer.set_voxel(x, 31, z, 2);
-        //     }
-        // }
-        // println!("Generated in {}ms", start.elapsed().as_millis());
-
-
-        let mut rng = rand::thread_rng();
         let start = std::time::Instant::now();
-
-        // Ground
-        for bx in 0..16 {
-            for bz in 0..16 {
-                let brick_id = renderer.brick_get_id(bx, 0, bz, true);
-                for x in 0..32 {
-                    for z in 0..32 {
-                        // Dirt
-                        renderer.brick_set_voxel(brick_id, x, 0, z, 1);
-                        // Grass
-                        let h = (rng.gen::<f32>() * 5.0) as usize;
-                        for y in 1..h {
-                            renderer.brick_set_voxel(brick_id, x, y, z, 2);
-                        }
-                    }
+        for x in 0..32 {
+            for y in 0..16 {
+                for z in 0..32 {
+                    world_gen.generate(&mut renderer, Point3{x, y, z});
                 }
             }
         }
-
-        // Wall
-        for bz in 4..8 {
-            for by in 0..4 {
-                // Brick
-                let brick_id = renderer.brick_get_id(8, by, bz, true);
-                for x in 14..18 {
-                    for z in 0..32 {
-                        for y in 0..32 {
-                            renderer.brick_set_voxel(brick_id, x, y, z, 3);
-                        }
-                    }
-                }
-            }
-        }
-
         println!("Generated in {}ms", start.elapsed().as_millis());
 
-
-
         Self { window, renderer, camera_controller, world_gen }
     }
 
diff --git a/src/app/world_gen.rs b/src/app/world_gen.rs
index 9b147a2..785f318 100644
--- a/src/app/world_gen.rs
+++ b/src/app/world_gen.rs
@@ -1,4 +1,6 @@
-use std::sync::Arc;
+use cgmath::{Point3, InnerSpace};
+use rand::Rng;
+
 use crate::renderer::Renderer;
 
 pub struct WorldGen {
@@ -11,6 +13,44 @@ impl WorldGen {
         Self{}
     }
 
-    pub fn generate(&mut self, renderer: Renderer)  {
+    pub fn generate(&mut self, renderer: &mut Renderer, pos: Point3<usize>)  {
+        let mut rng = rand::thread_rng();
+        let mut apply = false;
+        let block_id = renderer.block_get_id(pos, false);
+        
+        // Generate grass on ground
+        if pos.y == 0 {
+            for x in 0..32 {
+                for z in 0..32 {
+                    // Dirt
+                    renderer.block_set_voxel(block_id, x, 0, z, 1);
+                    // Grass
+                    if rng.gen::<f32>() < 0.3 {
+                        let h = (rng.gen::<f32>() * 5.0) as usize;
+                        for y in 1..h {
+                            renderer.block_set_voxel(block_id, x, y, z, 2);
+                        }
+                    }
+                }
+            }
+            apply = true;
+        }
+
+        // Generate wall
+        if pos.x == 8 && pos.y < 3 && pos.z < 8 && pos.z > 4 {
+            for z in 0..32 {
+                for y in 0..32 {
+                    renderer.block_set_voxel(block_id, 16, y, z, 3);
+                }
+            }
+            apply = true;
+        }
+
+        // Apply
+        if apply {
+            if block_id != renderer.block_get_id(pos, true) {
+                panic!("Block already consumed?");
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/renderer/buffers/brick_buffer.rs b/src/renderer/buffers/blocks.rs
similarity index 62%
rename from src/renderer/buffers/brick_buffer.rs
rename to src/renderer/buffers/blocks.rs
index 4ee2955..fcca948 100644
--- a/src/renderer/buffers/brick_buffer.rs
+++ b/src/renderer/buffers/blocks.rs
@@ -1,18 +1,18 @@
 use std::convert::TryInto;
 
-use crate::renderer::buffers::{BRICK_SIZE, BRICK_NUM, BRICK_LEN};
-const DATA_LEN : usize = BRICK_LEN * BRICK_NUM;
+use crate::renderer::buffers::{BLOCK_SIZE, BLOCK_NUM, BLOCK_LEN};
+const DATA_LEN : usize = BLOCK_LEN * BLOCK_NUM;
 
 
-pub struct BrickBuffer {
-    pub bricks: Box<[u8]>,
-    pub free_brick: usize,
+pub struct Blocks {
+    pub blocks: Box<[u8]>,
+    pub free_block: usize,
     texture: wgpu::Texture,
     pub bind_layout: wgpu::BindGroupLayout,
     pub bind_group: wgpu::BindGroup
 }
 
-impl BrickBuffer {
+impl Blocks {
 
     /*
     *   Create buffer in memory and gpu
@@ -20,7 +20,7 @@ impl BrickBuffer {
     pub fn new(device: &wgpu::Device) -> Self {
 
         // Create texture
-        let size = wgpu::Extent3d { width: BRICK_SIZE as u32, height: BRICK_SIZE as u32, depth: (BRICK_SIZE*BRICK_NUM) as u32 };
+        let size = wgpu::Extent3d { width: BLOCK_SIZE as u32, height: BLOCK_SIZE as u32, depth: (BLOCK_SIZE*BLOCK_NUM) as u32 };
         let texture = device.create_texture(
             &wgpu::TextureDescriptor {
                 size: size,
@@ -29,7 +29,7 @@ impl BrickBuffer {
                 dimension: wgpu::TextureDimension::D3,
                 format: wgpu::TextureFormat::R8Uint,
                 usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST, // STORAGE?
-                label: Some("Brick texture"),
+                label: Some("block texture"),
             }
         );
 
@@ -68,49 +68,50 @@ impl BrickBuffer {
                     wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&view) },
                     wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&sampler) }
                 ],
-                label: Some("Brick texture group"),
+                label: Some("block texture group"),
             }
         );
 
         // Data
-        let mut bricks = vec![0_u8; DATA_LEN].into_boxed_slice();
-        bricks[0] = 1;
-        println!("Brick buffer size: {} MB", DATA_LEN as f32 / 1024.0 / 1024.0);
+        let mut blocks = vec![0_u8; DATA_LEN].into_boxed_slice();
+        blocks[0] = 1;
+        println!("block buffer size: {} MB", DATA_LEN as f32 / 1024.0 / 1024.0);
 
         // Done
-        Self { bricks, texture, bind_layout, bind_group, free_brick: 0 }
+        Self { blocks, texture, bind_layout, bind_group, free_block: 0 }
     }
 
     /* 
-        Write brick data to gpu, should be called to apply changes
-        offset: Brick index to copy
+        Write block data to gpu, should be called to apply changes
+        offset: block index to copy
     */
-    pub fn write(&mut self, queue: &wgpu::Queue, brick: usize) {
-        // Get first brick
-        let brick_offset = brick*BRICK_LEN;
-        let brick_bytes : [u8;BRICK_LEN] = self.bricks[brick_offset..brick_offset+BRICK_LEN].try_into().unwrap();
-        let brick_size = wgpu::Extent3d{ width: BRICK_SIZE as u32, height: BRICK_SIZE as u32, depth: BRICK_SIZE as u32 };
-        let brick_origin = wgpu::Origin3d{ x:0, y:0, z: (brick*BRICK_SIZE) as u32 };
+    pub fn write(&mut self, queue: &wgpu::Queue, block: usize) {
+        // Get first block
+        let block_offset = block*BLOCK_LEN;
+        let block_bytes : [u8;BLOCK_LEN] = self.blocks[block_offset..block_offset+BLOCK_LEN].try_into().unwrap();
+        let block_size = wgpu::Extent3d{ width: BLOCK_SIZE as u32, height: BLOCK_SIZE as u32, depth: BLOCK_SIZE as u32 };
+        let block_origin = wgpu::Origin3d{ x:0, y:0, z: (block*BLOCK_SIZE) as u32 };
 
         // Write
         queue.write_texture(
-            wgpu::TextureCopyView { texture: &self.texture, mip_level: 0, origin: brick_origin },
-            &brick_bytes,
-            wgpu::TextureDataLayout { offset: 0, bytes_per_row: brick_size.width, rows_per_image: brick_size.height },
-            brick_size
+            wgpu::TextureCopyView { texture: &self.texture, mip_level: 0, origin: block_origin },
+            &block_bytes,
+            wgpu::TextureDataLayout { offset: 0, bytes_per_row: block_size.width, rows_per_image: block_size.height },
+            block_size
         );
     }
 
     /*
-    *   Get id of next free brick
-    *   Later: reusing old bricks
+    *   Get id of next free block
+    *   Later: reusing old blocks
     */
-    pub fn next_brick(&mut self) -> usize {
-        if self.free_brick >= self.bricks.len() {
-            panic!("No more free bricks! we should consider reusing bricks...");
+    pub fn next_block(&mut self, consume: bool) -> usize {
+        if self.free_block >= self.blocks.len() {
+            panic!("No more free blocks! we should consider reusing blocks...");
         }
 
-        self.free_brick += 1;
-        self.free_brick
+        let next = self.free_block + 1;
+        if consume { self.free_block = next; }
+        next
     }
 }
\ No newline at end of file
diff --git a/src/renderer/buffers/material_buffer.rs b/src/renderer/buffers/materials.rs
similarity index 77%
rename from src/renderer/buffers/material_buffer.rs
rename to src/renderer/buffers/materials.rs
index 96b426d..b960050 100644
--- a/src/renderer/buffers/material_buffer.rs
+++ b/src/renderer/buffers/materials.rs
@@ -1,37 +1,38 @@
 use wgpu::util::DeviceExt;
-
+use cgmath::Point3;
 
 #[repr(C)]
 #[derive(Default, Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 struct Material {
-    pub albedo: [f32; 4],
+    pub albedo: [f32; 3],
+    pub specular: f32,
 }
 
 impl Material {
-    pub fn set_albedo(&mut self, r: f32, g: f32, b:f32)
+    pub fn set(&mut self, color: Point3<f32>, specular: f32)
     {
-        self.albedo[0] = r;
-        self.albedo[1] = g;
-        self.albedo[2] = b;
+        self.albedo = color.into();
+        self.specular = specular;
     }
 }
 
 
-pub struct MaterialBuffer {
+pub struct Materials {
+    #[allow(dead_code)]
     materials: [Material; 256],
     pub buffer: wgpu::Buffer,
     pub bind_layout: wgpu::BindGroupLayout,
     pub bind_group: wgpu::BindGroup
 }
 
-impl MaterialBuffer {
+impl Materials {
     
     pub fn new(device: &wgpu::Device) -> Self {
         // Create values
         let mut materials: [Material; 256] = [Default::default(); 256];
-        materials[0].set_albedo(0.41,0.33,0.20);
-        materials[1].set_albedo(0.15,0.5,0.05);
-        materials[2].set_albedo(0.8,0.8,0.8);
+        materials[0].set(Point3{x:0.41, y:0.33, z:0.20}, 0.0); // Dirt
+        materials[1].set(Point3{x:0.15, y:0.50, z:0.05}, 0.3); // Grass
+        materials[2].set(Point3{x:0.90, y:0.90, z:0.90}, 1.0); // White
 
         // Create buffer
         let buffer = device.create_buffer_init(
@@ -70,6 +71,6 @@ impl MaterialBuffer {
         });
 
         // Done
-        MaterialBuffer { buffer, materials, bind_layout, bind_group }
+        Materials { buffer, materials, bind_layout, bind_group }
     }
 }
\ No newline at end of file
diff --git a/src/renderer/buffers/mod.rs b/src/renderer/buffers/mod.rs
index 9bf5c1e..e5f426f 100644
--- a/src/renderer/buffers/mod.rs
+++ b/src/renderer/buffers/mod.rs
@@ -4,25 +4,25 @@
 pub const WORLD_SIZE: usize = 32;
 pub const NUM_NODES: usize = (WORLD_SIZE*WORLD_SIZE*WORLD_SIZE) as usize;
 
-pub const BRICK_SIZE : usize = 32; // 32x32x32 brick size
-pub const BRICK_NUM : usize = 32768; // max bricks in texture
-pub const BRICK_LEN : usize = BRICK_SIZE*BRICK_SIZE*BRICK_SIZE;
+pub const BLOCK_SIZE : usize = 32; // 32x32x32 brick size
+pub const BLOCK_NUM : usize = 32768; // max bricks in texture
+pub const BLOCK_LEN : usize = BLOCK_SIZE*BLOCK_SIZE*BLOCK_SIZE;
 
 // Import names
 
-mod node_buffer;
-pub use node_buffer::NodeBuffer;
+mod nodes;
+pub use nodes::Nodes;
 
-mod brick_buffer;
-pub use brick_buffer::{BrickBuffer};
+mod blocks;
+pub use blocks::Blocks;
 
-mod uniform_buffer;
-pub use uniform_buffer::UniformBuffer;
-pub use uniform_buffer::UniformValues;
+mod uniform;
+pub use uniform::Uniform;
+pub use uniform::UniformValues;
 
-mod raster_buffer;
-pub use raster_buffer::RasterBuffer;
-pub use raster_buffer::Vertex;
+mod raster;
+pub use raster::Raster;
+pub use raster::Vertex;
 
-mod material_buffer;
-pub use material_buffer::MaterialBuffer;
\ No newline at end of file
+mod materials;
+pub use materials::Materials;
\ No newline at end of file
diff --git a/src/renderer/buffers/node_buffer.rs b/src/renderer/buffers/nodes.rs
similarity index 98%
rename from src/renderer/buffers/node_buffer.rs
rename to src/renderer/buffers/nodes.rs
index 11a415e..0ab90a7 100644
--- a/src/renderer/buffers/node_buffer.rs
+++ b/src/renderer/buffers/nodes.rs
@@ -3,7 +3,7 @@ use rand::prelude::*;
 
 use crate::renderer::buffers::{WORLD_SIZE, NUM_NODES};
 
-pub struct NodeBuffer {
+pub struct Nodes {
     pub nodes: Box<[u32]>,
     texture: wgpu::Texture,
     size: wgpu::Extent3d,
@@ -11,7 +11,7 @@ pub struct NodeBuffer {
     pub bind_group: wgpu::BindGroup
 }
 
-impl NodeBuffer {
+impl Nodes {
     
     pub fn new(device: &wgpu::Device) -> Self {
 
diff --git a/src/renderer/buffers/raster_buffer.rs b/src/renderer/buffers/raster.rs
similarity index 97%
rename from src/renderer/buffers/raster_buffer.rs
rename to src/renderer/buffers/raster.rs
index f6e072f..7e19cd0 100644
--- a/src/renderer/buffers/raster_buffer.rs
+++ b/src/renderer/buffers/raster.rs
@@ -40,13 +40,13 @@ const VERTICES: &[Vertex] = &[
 pub const INDICES: &[u16] = &[ 0, 1, 3, 3, 1, 2 ];
 
 
-pub struct RasterBuffer {
+pub struct Raster {
     pub vertex_buffer: wgpu::Buffer,
     pub index_buffer: wgpu::Buffer,
     pub index_len: u32
 }
 
-impl RasterBuffer {
+impl Raster {
     pub fn new(device: &wgpu::Device) -> Self {
 
         // Create vertex buffer
diff --git a/src/renderer/buffers/uniform_buffer.rs b/src/renderer/buffers/uniform.rs
similarity index 95%
rename from src/renderer/buffers/uniform_buffer.rs
rename to src/renderer/buffers/uniform.rs
index ef12dc7..13b6a4f 100644
--- a/src/renderer/buffers/uniform_buffer.rs
+++ b/src/renderer/buffers/uniform.rs
@@ -32,14 +32,14 @@ impl UniformValues {
 }
 
 
-pub struct UniformBuffer {
+pub struct Uniform {
     pub values: UniformValues,
     pub buffer: wgpu::Buffer,
     pub bind_layout: wgpu::BindGroupLayout,
     pub bind_group: wgpu::BindGroup,
 }
 
-impl UniformBuffer {
+impl Uniform {
     pub fn new(device: &wgpu::Device) -> Self {
         // Create values
         let values = UniformValues::new();
@@ -81,7 +81,7 @@ impl UniformBuffer {
         });
 
         // Done
-        UniformBuffer { buffer, values, bind_layout, bind_group }
+        Uniform { buffer, values, bind_layout, bind_group }
     }
 }
 
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index fb1619d..993c010 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -1,7 +1,11 @@
 use winit::{window::Window, dpi::PhysicalSize};
+use cgmath::{Point3};
 
 mod buffers; 
-use buffers::{NodeBuffer, BrickBuffer, UniformBuffer, RasterBuffer, Vertex, MaterialBuffer};
+use buffers::{Nodes, Blocks, Uniform, Raster, Materials};
+
+mod passes;
+use passes::RaytracePass;
 
 pub mod camera; use camera::Camera;
 
@@ -12,13 +16,13 @@ pub struct Renderer {
     queue: wgpu::Queue,
     swapchain_desc: wgpu::SwapChainDescriptor,
     swapchain: wgpu::SwapChain,
-    pipeline: wgpu::RenderPipeline,
+    raytrace: RaytracePass,
     // Buffers
-    raster_buffer: RasterBuffer,
-    uniform_buffer: UniformBuffer,
-    node_buffer: NodeBuffer,
-    brick_buffer: BrickBuffer,
-    material_buffer: MaterialBuffer,
+    raster_buffer: Raster,
+    uniform_buffer: Uniform,
+    node_buffer: Nodes,
+    brick_buffer: Blocks,
+    material_buffer: Materials,
     // Other
     pub camera: Camera,
     start: std::time::Instant,
@@ -38,53 +42,6 @@ impl Renderer {
         let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
         (swapchain_desc, swapchain)
     }
-
-    fn create_pipeline(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, bind_group_layouts: &[&wgpu::BindGroupLayout]) -> wgpu::RenderPipeline{
-        // Pipeline stuff
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Render Pipeline Layout"),
-            bind_group_layouts: bind_group_layouts,
-            push_constant_ranges: &[],
-        });
-        let vert_state = wgpu::VertexState { //vert
-            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.vert.spv")),
-            entry_point: "main",
-            buffers: &[Vertex::desc()],
-        };
-        let frag_state = wgpu::FragmentState { // frag
-            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.frag.spv")),
-            entry_point: "main",
-            targets: &[wgpu::ColorTargetState {
-                format: swapchain_desc.format,
-                alpha_blend: wgpu::BlendState::REPLACE,
-                color_blend: wgpu::BlendState::REPLACE,
-                write_mask: wgpu::ColorWrite::ALL,
-            }],
-        };
-        let prim_state = wgpu::PrimitiveState { // primitive
-            topology: wgpu::PrimitiveTopology::TriangleList,
-            strip_index_format: None,
-            front_face: wgpu::FrontFace::Cw,
-            cull_mode: wgpu::CullMode::Back,
-            polygon_mode: wgpu::PolygonMode::Fill,
-        };
-        let multisample_state = wgpu::MultisampleState { // multisample
-            count: 1,
-            mask: !0,
-            alpha_to_coverage_enabled: false,
-        };
-
-        // Create pipeline
-        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Render Pipeline"), 
-            layout: Some(&pipeline_layout),
-            vertex: vert_state, 
-            fragment: Some(frag_state),
-            primitive: prim_state,
-            depth_stencil: None,
-            multisample: multisample_state,
-        })
-    }
     
     /*
     *   Initializes renderer and all buffers
@@ -112,11 +69,11 @@ impl Renderer {
         let camera = Camera::new(aspect, 60.0);
 
         // Buffers
-        let uniform_buffer = UniformBuffer::new(&device);
-        let raster_buffer = RasterBuffer::new(&device);
-        let node_buffer = NodeBuffer::new(&device);
-        let brick_buffer = BrickBuffer::new(&device);
-        let material_buffer = MaterialBuffer::new(&device);
+        let uniform_buffer = Uniform::new(&device);
+        let raster_buffer = Raster::new(&device);
+        let node_buffer = Nodes::new(&device);
+        let brick_buffer = Blocks::new(&device);
+        let material_buffer = Materials::new(&device);
 
         // Pipeline
         let bind_layouts = [
@@ -125,13 +82,13 @@ impl Renderer {
             &brick_buffer.bind_layout,
             &material_buffer.bind_layout
         ];
-        let pipeline = Self::create_pipeline(&device, &swapchain_desc, &bind_layouts);
+        let raytrace = RaytracePass::new(&device, &swapchain_desc, &bind_layouts);
 
         // Save values in app
         println!("Initialized");
         let start = std::time::Instant::now();
         let changed_bricks: Vec<usize> = Vec::new();
-        Self { surface, device, queue, swapchain_desc, swapchain, pipeline, raster_buffer, uniform_buffer, node_buffer, brick_buffer, material_buffer, camera, start, changed_bricks }
+        Self { surface, device, queue, swapchain_desc, swapchain, raytrace, raster_buffer, uniform_buffer, node_buffer, brick_buffer, material_buffer, camera, start, changed_bricks }
     }
 
     /*
@@ -193,7 +150,7 @@ impl Renderer {
             });
 
             // Data
-            render_pass.set_pipeline(&self.pipeline);
+            render_pass.set_pipeline(&self.raytrace.pipeline);
             render_pass.set_bind_group(0, &self.uniform_buffer.bind_group, &[]);
             render_pass.set_bind_group(1, &self.node_buffer.bind_group, &[]);
             render_pass.set_bind_group(2, &self.brick_buffer.bind_group, &[]);
@@ -202,6 +159,7 @@ impl Renderer {
             render_pass.set_vertex_buffer(0, self.raster_buffer.vertex_buffer.slice(..));
             render_pass.set_index_buffer(self.raster_buffer.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
             render_pass.draw_indexed(0..self.raster_buffer.index_len, 0, 0..1);
+
         }
 
         // Submit encoder (command buffer)
@@ -216,43 +174,43 @@ impl Renderer {
     */
     #[allow(dead_code)]
     pub fn set_voxel(&mut self, x: usize, y: usize, z:usize, value: u8) {
-        let brick_id = self.brick_get_id(x/32, y/32, z/32, true);
-        self.brick_set_voxel(brick_id, x%32, y%32, z%32, value);
+        let brick_id = self.block_get_id(Point3{x:x/32, y:y/32, z:z/32}, true);
+        self.block_set_voxel(brick_id, x%32, y%32, z%32, value);
     }
 
      /*
     *   Create or update brick at given location
     */
-    pub fn brick_set_voxel(&mut self, brick_id:usize, x: usize, y: usize, z:usize, value: u8) {
-        let voxel_id = x + buffers::BRICK_SIZE * (y + buffers::BRICK_SIZE * z);
-        let brick_offset = brick_id * buffers::BRICK_LEN;
-        self.brick_buffer.bricks[brick_offset + voxel_id] = value;
+    pub fn block_set_voxel(&mut self, brick_id:usize, x: usize, y: usize, z:usize, value: u8) {
+        let voxel_id = x + buffers::BLOCK_SIZE * (y + buffers::BLOCK_SIZE * z);
+        let brick_offset = brick_id * buffers::BLOCK_LEN;
+        self.brick_buffer.blocks[brick_offset + voxel_id] = value;
     }
 
     /*
     *   Gets brick id
     */
-    pub fn brick_get_id(&mut self, x: usize, y: usize, z:usize, mark_changed: bool) -> usize {
+    pub fn block_get_id(&mut self, pos: Point3<usize>, apply: bool) -> usize {
         // Get node
-        let node_idx = x + buffers::WORLD_SIZE * (y + buffers::WORLD_SIZE * z);
+        let node_idx = pos.x + buffers::WORLD_SIZE * (pos.y + buffers::WORLD_SIZE * pos.z);
         let mut node_value = self.node_buffer.nodes[node_idx];
 
         // Use new brick if neccesary
         if node_value == 0 { 
-            node_value = self.brick_buffer.next_brick() as u32; 
-            self.node_buffer.nodes[node_idx] = node_value;
+            node_value = self.brick_buffer.next_block(apply) as u32; 
+            if apply { self.node_buffer.nodes[node_idx] = node_value; }
         }
 
         // Get brick id from node value
         let brick_id = (node_value - 1) as usize;
-        if mark_changed { self.brick_mark_changed(brick_id); }
+        if apply { self.block_mark_changed(brick_id); }
         brick_id
     }
 
     /*
     *   Marks brick as changed
     */
-    pub fn brick_mark_changed(&mut self, brick_id:usize) {
+    pub fn block_mark_changed(&mut self, brick_id:usize) {
         if !self.changed_bricks.contains(&brick_id) {
             self.changed_bricks.push(brick_id);
         }
diff --git a/src/renderer/passes/mod.rs b/src/renderer/passes/mod.rs
new file mode 100644
index 0000000..21eb545
--- /dev/null
+++ b/src/renderer/passes/mod.rs
@@ -0,0 +1,3 @@
+
+mod raytrace;
+pub use raytrace::RaytracePass;
\ No newline at end of file
diff --git a/src/renderer/passes/raytrace.rs b/src/renderer/passes/raytrace.rs
new file mode 100644
index 0000000..ff0871a
--- /dev/null
+++ b/src/renderer/passes/raytrace.rs
@@ -0,0 +1,57 @@
+use crate::renderer::buffers::Vertex;
+
+
+pub struct RaytracePass {
+    pub pipeline: wgpu::RenderPipeline
+}
+
+impl RaytracePass {
+    pub fn new(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, bind_group_layouts: &[&wgpu::BindGroupLayout]) -> Self {
+        // Pipeline stuff
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Render Pipeline Layout"),
+            bind_group_layouts: bind_group_layouts,
+            push_constant_ranges: &[],
+        });
+        let vert_state = wgpu::VertexState { //vert
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\..\\shaders\\bin\\shader.vert.spv")),
+            entry_point: "main",
+            buffers: &[Vertex::desc()],
+        };
+        let frag_state = wgpu::FragmentState { // frag
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\..\\shaders\\bin\\shader.frag.spv")),
+            entry_point: "main",
+            targets: &[wgpu::ColorTargetState {
+                format: swapchain_desc.format,
+                alpha_blend: wgpu::BlendState::REPLACE,
+                color_blend: wgpu::BlendState::REPLACE,
+                write_mask: wgpu::ColorWrite::ALL,
+            }],
+        };
+        let prim_state = wgpu::PrimitiveState { // primitive
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            strip_index_format: None,
+            front_face: wgpu::FrontFace::Cw,
+            cull_mode: wgpu::CullMode::Back,
+            polygon_mode: wgpu::PolygonMode::Fill,
+        };
+        let multisample_state = wgpu::MultisampleState { // multisample
+            count: 1,
+            mask: !0,
+            alpha_to_coverage_enabled: false,
+        };
+
+        // Create pipeline
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Render Pipeline"), 
+            layout: Some(&pipeline_layout),
+            vertex: vert_state, 
+            fragment: Some(frag_state),
+            primitive: prim_state,
+            depth_stencil: None,
+            multisample: multisample_state,
+        });
+
+        Self { pipeline }
+    }
+}
\ No newline at end of file
diff --git a/src/shaders/bin/shader.frag.spv b/src/shaders/bin/shader.frag.spv
index 541d11cefb4bd42d3b58c2479bcf0c23ab9c36b7..4e09391c753c0ca40178fa77195c13377aae7466 100644
GIT binary patch
literal 15660
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
JRqi{~e*tio@=^c*

literal 15176
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
SSS{wh0$jw@tyS)4sQ&}9<fWSc

diff --git a/src/shaders/shader.frag b/src/shaders/shader.frag
index 0a443ca..4f575f5 100644
--- a/src/shaders/shader.frag
+++ b/src/shaders/shader.frag
@@ -2,7 +2,8 @@
 #version 450
 
 struct Material {
-    vec4 albedo;
+    vec3 albedo;
+    float specular;
 };
 
 // Variables
@@ -65,7 +66,7 @@ vec3 solve()
     if(primary.data > 0)
     {
         vec3 color = applyLighting(primary.pos, primaryRay.dir, primary.normal, primary.data);
-        vec3 hitPos = primary.pos-primaryRay.dir*0.000001;
+        vec3 hitPos = primary.pos-primaryRay.dir*0.00000001;
 
         // Shadow ray
         Ray shadowRay = Ray(hitPos, _SunDir);
@@ -73,9 +74,9 @@ vec3 solve()
         if(shadow.data > 0) color *= 0.1;
 
         // Secondary ray
-        Ray secondRay = Ray(hitPos, randomHemisphere(primary.normal));
-        HitResult second = castNodes(secondRay, 25);
-        if(second.data > 0) color += getAlbedo(second.data) * 0.8;
+        // Ray secondRay = Ray(hitPos, randomHemisphere(primary.normal));
+        // HitResult second = castNodes(secondRay, 25);
+        // if(second.data > 0) color += getAlbedo(second.data) * 0.8;
 
         return color;
     }
diff --git a/src/shaders/shading.cginc b/src/shaders/shading.cginc
index 6208bba..4087ddb 100644
--- a/src/shaders/shading.cginc
+++ b/src/shaders/shading.cginc
@@ -1,10 +1,8 @@
 /*
 *   Returns material albedo for given voxel
 */
-vec3 getAlbedo(uint data)
-{
-    return _Materials[data-1].albedo.rgb;
-}
+vec3 getAlbedo(uint data) { return _Materials[data-1].albedo.rgb; }
+float getSpecular(uint data) { return _Materials[data-1].specular; }
 
 /*
     point: Hit point
@@ -14,12 +12,14 @@ vec3 getAlbedo(uint data)
 vec3 applyLighting(vec3 hitPoint, vec3 view, vec3 normal, uint data)
 {
     // Lighting
-    vec3 light_color = vec3(1);
+    vec3 ambientColor = vec3(0.9, 0.9, 1.0);
+    vec3 ambient = ambientColor * 0.05;
+    vec3 sky = ambientColor * 0.1 * max(normal.y, 0);
 
-    vec3 ambient = light_color * 0.1;
-    vec3 diffuse = light_color * max(1.0-dot(normal, _SunDir), 0.0);
-    vec3 specular = light_color * pow(max(dot(view, reflect(_SunDir, normal)), 0.0), 32);
+    vec3 sunColor = vec3(1.0, 1.0, 0.9);
+    vec3 diffuse = sunColor * max(1.0-dot(normal, _SunDir), 0.0);
+    vec3 specular = sunColor * getSpecular(data) * pow(max(dot(view, reflect(_SunDir, normal)), 0.0), 32);
 
     // Combine colors
-    return (ambient + diffuse + specular) * getAlbedo(data);
+    return (ambient + sky + diffuse + specular) * getAlbedo(data);
 }
\ No newline at end of file
diff --git a/src/shaders/shapes.cginc b/src/shaders/shapes.cginc
deleted file mode 100644
index 88d60be..0000000
--- a/src/shaders/shapes.cginc
+++ /dev/null
@@ -1,14 +0,0 @@
-float sdSphere(in vec3 pos)
-{
-    return length(pos) - 1.0;
-}
-
-float sdPlane(in vec3 pos)
-{
-    return pos.y;
-}
-
-vec2 sdUnion(vec2 a, vec2 b)
-{
-    return (a.x < b.x) ? a : b;
-}
\ No newline at end of file