piotrek/first-voxels
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

project structure cleaning

Browse Source
This commit is contained in:
Piotrek
2021-04-26 16:39:08 +02:00
parent dae867be9f
commit ea1c0ba089
3 changed files with 119 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/renderer/buffers/mod.rs
+23 -1
View File
@@ -29,4 +29,26 @@ pub use raster::Raster;
pub use raster::Vertex;
mod materials;
pub use materials::Materials;
pub use materials::Materials;
// Create buffers
pub struct Buffers {
pub uniform_buffer: Uniform,
pub raster_buffer: Raster,
pub node_buffer: Nodes,
pub brick_buffer: Blocks,
pub material_buffer: Materials
}
impl Buffers {
pub fn new(device: &wgpu::Device) -> Self {
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);
Self { uniform_buffer, raster_buffer, node_buffer, brick_buffer, material_buffer }
}
}
src/renderer/mod.rs
+34 -80
View File
@@ -2,7 +2,7 @@ use winit::{window::Window, dpi::PhysicalSize};
use cgmath::{Point3};
pub mod buffers;
use buffers::{Nodes, Blocks, Uniform, Raster, Materials};
use buffers::{Buffers, Nodes, Blocks, Uniform, Raster, Materials};
mod passes;
use passes::RaytracePass;
@@ -17,13 +17,9 @@ pub struct Renderer {
queue: wgpu::Queue,
swapchain_desc: wgpu::SwapChainDescriptor,
swapchain: wgpu::SwapChain,
raytrace: RaytracePass,
raytrace_pass: RaytracePass,
// Buffers
raster_buffer: Raster,
uniform_buffer: Uniform,
node_buffer: Nodes,
brick_buffer: Blocks,
material_buffer: Materials,
buffers: Buffers,
// Other
pub camera: Camera,
start: std::time::Instant,
@@ -31,65 +27,47 @@ pub struct Renderer {
}
impl Renderer {
fn create_swapchain(adapter: &wgpu::Adapter, device: &wgpu::Device, surface: &wgpu::Surface, size: PhysicalSize<u32>) -> (wgpu::SwapChainDescriptor, wgpu::SwapChain) {
let swapchain_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
format: adapter.get_swap_chain_preferred_format(&surface),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo, // Fifo = Vsync
};
let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
(swapchain_desc, swapchain)
}
/*
* Initializes renderer and all buffers
*/
pub async fn new(window: &Window) -> Self {
// Create surface and pick device
// Create surface
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let surface = unsafe { instance.create_surface(window) };
// Pick adapter (physical gpu)
// Pick and initialize device
let adapter_options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface) };
let adapter = instance.request_adapter(&adapter_options).await.unwrap();
println!("Adapter: {}", adapter.get_info().name);
// Pick device (logical gpu) from adapter
let device_desc = wgpu::DeviceDescriptor { features: wgpu::Features::empty(), limits: wgpu::Limits::default(), label: None };
let (device, queue) = adapter.request_device(&device_desc, None).await.unwrap();
// Create swapchain
let (swapchain_desc, swapchain) = Self::create_swapchain(&adapter, &device, &surface, window.inner_size());
let window_size = window.inner_size();
let swapchain_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
format: adapter.get_swap_chain_preferred_format(&surface),
width: window_size.width,
height: window_size.height,
present_mode: wgpu::PresentMode::Fifo, // Fifo = Vsync
};
let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
// Cam
// Camera
let aspect = swapchain_desc.width as f32 / swapchain_desc.height as f32;
let camera = Camera::new(aspect, 60.0);
// Buffers
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 = [
&uniform_buffer.bind_layout,
&node_buffer.bind_layout,
&brick_buffer.bind_layout,
&material_buffer.bind_layout
];
let raytrace = RaytracePass::new(&device, &swapchain_desc, &bind_layouts);
let buffers = Buffers::new(&device);
let raytrace_pass = RaytracePass::new(&device, &swapchain_desc, &buffers);
// Save values in app
println!("Initialized");
// Other
let start = std::time::Instant::now();
let changed_bricks: Vec<usize> = Vec::new();
Self { surface, device, queue, swapchain_desc, swapchain, raytrace, raster_buffer, uniform_buffer, node_buffer, brick_buffer, material_buffer, camera, start, changed_bricks }
println!("Initialized");
Self { surface, device, queue, swapchain_desc, swapchain, raytrace_pass, buffers, camera, start, changed_bricks }
}
/*
@@ -115,17 +93,17 @@ impl Renderer {
pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
// Update uniform buffer
self.uniform_buffer.values.update(&self.camera, self.start.elapsed().as_secs_f32());
self.queue.write_buffer(&self.uniform_buffer.buffer, 0, bytemuck::cast_slice(&[self.uniform_buffer.values]));
self.buffers.uniform_buffer.values.update(&self.camera, self.start.elapsed().as_secs_f32());
self.queue.write_buffer(&self.buffers.uniform_buffer.buffer, 0, bytemuck::cast_slice(&[self.buffers.uniform_buffer.values]));
// Update changed nodes
if self.changed_bricks.len() > 0 {
self.node_buffer.write(&self.queue);
self.buffers.node_buffer.write(&self.queue);
for node in &self.changed_bricks {
self.brick_buffer.write(&self.queue, *node);
self.buffers.brick_buffer.write(&self.queue, *node);
}
let used = self.brick_buffer.next_block(false);
let used = self.buffers.brick_buffer.next_block(false);
let total = buffers::BLOCK_TEX_SIZE * buffers::BLOCK_TEX_SIZE;
let changed = self.changed_bricks.len();
println!("Used: {}/{} Changed: {}", used, total, changed);
@@ -139,33 +117,7 @@ impl Renderer {
// Create encoder that will build command buffer for us
let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});
// Create render pass
{
let ops = wgpu::Operations {
// Clear command
load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
// Store command
store: true,
};
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
depth_stencil_attachment: None,
});
// Data
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, &[]);
render_pass.set_bind_group(3, &self.material_buffer.bind_group, &[]);
// Vertices and indices
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);
}
self.raytrace_pass.render(&mut encoder, &mut self.buffers, &frame.view);
// Submit encoder (command buffer)
self.queue.submit(std::iter::once(encoder.finish()));
@@ -174,6 +126,8 @@ impl Renderer {
Ok(())
}
//TODO: Move things below to a separate struct, maybe trait?
/*
* Create or update brick at given location
*/
@@ -189,7 +143,7 @@ impl Renderer {
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;
self.buffers.brick_buffer.blocks[brick_offset + voxel_id] = value;
}
/*
@@ -198,12 +152,12 @@ impl Renderer {
pub fn block_get_id(&mut self, pos: Point3<usize>, apply: bool) -> usize {
// Get node
let node_idx = pos.x + buffers::NODE_TEX_SIZE * (pos.y + buffers::NODE_TEX_SIZE * pos.z);
let mut node_value = self.node_buffer.nodes[node_idx];
let mut node_value = self.buffers.node_buffer.nodes[node_idx];
// Use new brick if neccesary
if node_value == 0 {
node_value = self.brick_buffer.next_block(apply) as u32;
if apply { self.node_buffer.nodes[node_idx] = node_value; }
node_value = self.buffers.brick_buffer.next_block(apply) as u32;
if apply { self.buffers.node_buffer.nodes[node_idx] = node_value; }
}
// Get brick id from node value
src/renderer/passes/raytrace.rs
+62 -25
View File
@@ -1,24 +1,21 @@
use crate::renderer::buffers::Vertex;
use crate::renderer::buffers::{Vertex, Buffers};
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
pub fn new(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, buffers: &Buffers) -> Self {
// Vertex shader
let vert_state = wgpu::VertexState {
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
// Fragment shader
let frag_state = wgpu::FragmentState {
module: &device.create_shader_module(&wgpu::include_spirv!("..\\..\\shaders\\bin\\shader.frag.spv")),
entry_point: "main",
targets: &[wgpu::ColorTargetState {
@@ -28,18 +25,21 @@ impl RaytracePass {
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,
};
// Bind group layouts
let bind_group_layouts = [
&buffers.uniform_buffer.bind_layout,
&buffers.node_buffer.bind_layout,
&buffers.brick_buffer.bind_layout,
&buffers.material_buffer.bind_layout
];
// Pipeline layout
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Render Pipeline Layout"),
bind_group_layouts: &bind_group_layouts,
push_constant_ranges: &[],
});
// Create pipeline
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
@@ -47,11 +47,48 @@ impl RaytracePass {
layout: Some(&pipeline_layout),
vertex: vert_state,
fragment: Some(frag_state),
primitive: prim_state,
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::Back,
polygon_mode: wgpu::PolygonMode::Fill,
},
depth_stencil: None,
multisample: multisample_state,
multisample: wgpu::MultisampleState { count: 1, mask: !0, alpha_to_coverage_enabled: false }
});
Self { pipeline }
}
pub fn render(&mut self, encoder: &mut wgpu::CommandEncoder, buffers: &mut Buffers, attachment: &wgpu::TextureView) {
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment: attachment,
resolve_target: None,
ops: wgpu::Operations {
// Clear and store
load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
store: true,
}
}],
depth_stencil_attachment: None,
});
// Pipeline
render_pass.set_pipeline(&self.pipeline);
// Vertices and indices
render_pass.set_vertex_buffer(0, buffers.raster_buffer.vertex_buffer.slice(..));
render_pass.set_index_buffer(buffers.raster_buffer.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..buffers.raster_buffer.index_len, 0, 0..1);
// Bind groups
render_pass.set_bind_group(0, &buffers.uniform_buffer.bind_group, &[]);
render_pass.set_bind_group(1, &buffers.node_buffer.bind_group, &[]);
render_pass.set_bind_group(2, &buffers.brick_buffer.bind_group, &[]);
render_pass.set_bind_group(3, &buffers.material_buffer.bind_group, &[]);
}
}