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

project structure cleanup

Browse Source
This commit is contained in:
Piotrek
2021-04-16 10:54:00 +02:00
parent 9cd599743d
commit 3ad54777cd
8 changed files with 107 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/camera_controller.rs → src/app/camera_controller.rs
+1 -1
View File
@@ -1,7 +1,7 @@
use winit::event::Event;
use winit::event::{WindowEvent, DeviceEvent, KeyboardInput, ElementState, VirtualKeyCode};
use cgmath::{InnerSpace, Matrix4, Rad, Deg, Transform, Vector3};
use crate::camera::Camera;
use crate::renderer::camera::Camera;
#[derive(Default)]
struct CameraMovement {
src/app/mod.rs
+60
View File
@@ -0,0 +1,60 @@
use winit::{
event::{Event, WindowEvent, KeyboardInput, ElementState, VirtualKeyCode, MouseButton},
window::Window
};
use std::sync::Arc;
mod camera_controller; use camera_controller::CameraController;
use crate::renderer::Renderer;
pub struct App {
pub window: Window,
pub renderer: Renderer,
camera_controller: CameraController,
}
impl App {
pub fn new(window: Window, renderer: Renderer) -> Self {
let camera_controller = CameraController::new();
Self { window, renderer, camera_controller }
}
pub fn input(&mut self, event: Arc<Event<()>>) {
match event.as_ref() {
Event::WindowEvent { ref event, .. } => {
match event {
// Escape key
WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. }, .. } => {
self.window.set_cursor_grab(false).unwrap();
self.window.set_cursor_visible(true);
self.camera_controller.set_enabled(false);
}
// Window clicked
WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
self.window.set_cursor_grab(true).unwrap();
self.window.set_cursor_visible(false);
self.camera_controller.set_enabled(true);
}
// Window resized
WindowEvent::Resized(physical_size) => {
self.renderer.resize(Some(*physical_size));
}
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
self.renderer.resize(Some(**new_inner_size));
}
_ => ()
}
}
_ => ()
}
// Update camera controller
self.camera_controller.handle_input(event.as_ref());
}
pub fn update(&mut self, delta: f32) {
self.camera_controller.update_camera(&mut self.renderer.camera, delta);
}
}
src/main.rs
+24 -51
View File
@@ -6,75 +6,52 @@ use winit::{
dpi::LogicalSize
};
mod vertex;
mod texture;
mod uniforms;
mod camera;
mod app;
mod camera_controller;
use app::App;
mod renderer; use renderer::Renderer;
mod app; use app::App;
fn main() {
// Create event loop
let events = EventLoop::new();
// Spawn window
let window = WindowBuilder::new()
// Create app
let _window = WindowBuilder::new()
.with_title("Test")
.with_inner_size(LogicalSize::new(1280.0, 720.0))
.build(&events)
.expect("Failed to create window");
let _renderer = futures::executor::block_on(Renderer::new(&_window));
let mut app = App::new(_window, _renderer);
// Create app
let mut app = futures::executor::block_on(App::new(&window));
// Stats
let mut fps_timer = std::time::Instant::now();
let mut fps_counter = 0;
let mut delta_timer = std::time::Instant::now();
// Run event loop
events.run(move |e, _, c| {
let ev = Arc::new(e);
events.run(move |ev, _, c| {
// App input
let event = Arc::new(ev);
app.input(event.clone());
if app.input(ev.clone()) {
// Event consumed
return;
}
match ev.as_ref() {
// Other
match event.as_ref() {
// Window event
Event::WindowEvent { ref event, .. } => {
match event {
// Window closed (ALT+F4,)
WindowEvent::CloseRequested => {
*c = ControlFlow::Exit;
}
// Escape key
WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. }, .. } => {
window.set_cursor_grab(false).unwrap();
window.set_cursor_visible(true);
app.camera_controller.set_enabled(false);
}
// Window clicked
WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
window.set_cursor_grab(true).unwrap();
window.set_cursor_visible(false);
app.camera_controller.set_enabled(true);
}
// Window resized
WindowEvent::Resized(physical_size) => {
app.resize(Some(*physical_size));
}
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
app.resize(Some(**new_inner_size));
}
// Other window events
WindowEvent::CloseRequested => { *c = ControlFlow::Exit; }
_ => ()
}
}
// Request draw
// Loop
Event::MainEventsCleared => {
window.request_redraw();
// Update
app.update(delta_timer.elapsed().as_secs_f32());
delta_timer = std::time::Instant::now();
// Redraw
app.window.request_redraw();
}
// Draw
Event::RedrawRequested(_) => {
@@ -88,16 +65,12 @@ fn main() {
fps_counter = 0;
}
fps_counter += 1;
// Update and Render
app.update(delta_timer.elapsed().as_secs_f32());
delta_timer = std::time::Instant::now();
// Render
match app.render() {
match app.renderer.render() {
Ok(_) => { }
// Recreate the swap_chain if lost
Err(wgpu::SwapChainError::Lost) => app.resize(None),
Err(wgpu::SwapChainError::Lost) => app.renderer.resize(None),
// The system is out of memory, we should probably quit
Err(wgpu::SwapChainError::OutOfMemory) => *c = ControlFlow::Exit,
// All other errors (Outdated, Timeout) should be resolved by the next frame
src/camera.rs → src/renderer/camera.rs
View File
src/app.rs → src/renderer/mod.rs
+21 -43
View File
@@ -1,30 +1,22 @@
use std::sync::Arc;
use winit::event::Event;
use winit::{window::Window, dpi::PhysicalSize};
use wgpu::util::DeviceExt;
use crate::vertex::Vertex;
use crate::texture::Texture;
use crate::camera::Camera;
use crate::uniforms::Uniforms;
use crate::camera_controller::CameraController;
mod vertex; use vertex::Vertex;
mod texture; use texture::Texture;
pub mod camera; use camera::Camera;
mod uniforms; use uniforms::Uniforms;
// A B
// C D
const VERTICES: &[Vertex] = &[
Vertex { position: [-1.0, 1.0, 0.0], uv: [-1.0, 1.0] }, // A
Vertex { position: [ 1.0, 1.0, 0.0], uv: [1.0, 1.0] }, // B
Vertex { position: [ 1.0,-1.0, 0.0], uv: [1.0, -1.0] }, // C
Vertex { position: [-1.0,-1.0, 0.0], uv: [-1.0, -1.0] }, // D
Vertex { position: [-1.0, 1.0, 0.0], uv: [-1.0, 1.0] }, // top left
Vertex { position: [ 1.0, 1.0, 0.0], uv: [1.0, 1.0] }, // top right
Vertex { position: [ 1.0,-1.0, 0.0], uv: [1.0, -1.0] }, // bottom right
Vertex { position: [-1.0,-1.0, 0.0], uv: [-1.0, -1.0] }, // bottom left
];
const INDICES: &[u16] = &[ 0, 1, 3, 3, 1, 2 ];
const INDICES: &[u16] = &[
0, 1, 3,
3, 1, 2
];
pub struct App {
pub struct Renderer {
surface: wgpu::Surface,
device: wgpu::Device,
queue: wgpu::Queue,
@@ -40,12 +32,11 @@ pub struct App {
// Texture
bind_group: wgpu::BindGroup,
// Camera
camera: Camera,
pub camera_controller: CameraController,
pub camera: Camera,
uniforms: Uniforms
}
impl App {
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 {
@@ -67,12 +58,12 @@ impl App {
push_constant_ranges: &[],
});
let vert_state = wgpu::VertexState { //vert
module: &device.create_shader_module(&wgpu::include_spirv!("shaders\\bin\\shader.vert.spv")),
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")),
module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.frag.spv")),
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: swapchain_desc.format,
@@ -219,7 +210,6 @@ impl App {
let camera = Camera::new(aspect, 60.0);
let mut uniforms = Uniforms::new();
uniforms.update(&camera);
let camera_controller = CameraController::new();
// Buffers
let vertex_buffer = Self::create_buffer(&device, wgpu::BufferUsage::VERTEX, bytemuck::cast_slice(VERTICES));
@@ -237,7 +227,7 @@ impl App {
// Save values in app
println!("Initialized");
Self { surface, device, queue, swapchain_desc, swapchain, pipeline, vertex_buffer, index_buffer, uniform_buffer, bind_group, uniform_bind_group, camera, uniforms, camera_controller }
Self { surface, device, queue, swapchain_desc, swapchain, pipeline, vertex_buffer, index_buffer, uniform_buffer, bind_group, uniform_bind_group, camera, uniforms }
}
pub fn resize(&mut self, new_size: Option<PhysicalSize<u32>>) {
@@ -254,23 +244,15 @@ impl App {
self.swapchain = self.device.create_swap_chain(&self.surface, &self.swapchain_desc);
}
pub fn input(&mut self, event: Arc<Event<()>>) -> bool {
self.camera_controller.handle_input(event.as_ref())
}
pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
pub fn update(&mut self, delta_time: f32) {
// Update camera
self.camera_controller.update_camera(&mut self.camera, delta_time);
// Update projection matrix buffer
// Update uniform buffer
self.uniforms.update(&self.camera);
self.queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[self.uniforms]));
}
pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
// Get next frame to render to
let frame = self.swapchain.get_current_frame()?.output;
// Create encoder that will build command buffer for us
let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});
@@ -285,19 +267,15 @@ impl App {
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: ops
}
],
color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
depth_stencil_attachment: None,
});
// Data
render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, &self.bind_group, &[]);
render_pass.set_bind_group(1, &self.uniform_bind_group, &[]);
// Vertices and indices
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..(INDICES.len() as u32), 0, 0..1);
src/texture.rs → src/renderer/texture.rs
View File
src/uniforms.rs → src/renderer/uniforms.rs
+1 -2
View File
@@ -1,6 +1,5 @@
use cgmath::SquareMatrix;
use crate::camera::Camera;
use super::camera::Camera;
#[repr(C)]
src/vertex.rs → src/renderer/vertex.rs
View File