176 lines
6.0 KiB
Rust
176 lines
6.0 KiB
Rust
use cyborg::shader;
|
|
use cyborg::storage::mesh::*;
|
|
use cyborg::{pass, viewport::*, Renderer};
|
|
use std::sync::Arc;
|
|
use winit::{
|
|
event::*,
|
|
event_loop::{ControlFlow, EventLoop},
|
|
window::WindowBuilder,
|
|
};
|
|
|
|
fn main() {
|
|
let event_loop = EventLoop::new();
|
|
let window = WindowBuilder::new().build(&event_loop).unwrap();
|
|
let mut viewport = pollster::block_on(WinitViewport::from_window(&window));
|
|
let mut renderer = Renderer::new(viewport.device.clone(), viewport.queue.clone());
|
|
|
|
let mut flycam = cyborg::camera::Flycam::new(0.002, 10.0, 0.25);
|
|
let mut is_grabbed = false;
|
|
|
|
let device = renderer.get_device();
|
|
let layouts = renderer.get_layouts();
|
|
|
|
let shader_store = Arc::new(shader::ShaderStore::new(device.to_owned()));
|
|
|
|
let shaders_dir = std::env::current_dir().unwrap();
|
|
let shaders_dir = shaders_dir.join("shaders/");
|
|
let shader_watcher = shader::ShaderWatcher::new(shader_store.to_owned(), shaders_dir).unwrap();
|
|
|
|
let mesh_forward = shader_watcher.add_file("mesh_forward.wgsl").unwrap();
|
|
let mesh_skinning = shader_watcher.add_file("mesh_skinning.wgsl").unwrap();
|
|
|
|
let mesh_shaders = pass::mesh::ShaderInfo {
|
|
store: shader_store.clone(),
|
|
forward: mesh_forward,
|
|
skinning: mesh_skinning,
|
|
};
|
|
|
|
let mesh_pass = pass::mesh::MeshPass::new(
|
|
device.to_owned(),
|
|
layouts.to_owned(),
|
|
viewport.get_info(),
|
|
mesh_shaders,
|
|
);
|
|
let debug_pass =
|
|
pass::debug::DebugPass::new(device.to_owned(), layouts.to_owned(), viewport.get_info());
|
|
|
|
let example_vertices = vec![
|
|
pass::mesh::Vertex {
|
|
position: [-0.5, 0.5, 0.0],
|
|
tan_frame: 0,
|
|
},
|
|
pass::mesh::Vertex {
|
|
position: [0.5, 0.5, 0.0],
|
|
tan_frame: 0,
|
|
},
|
|
pass::mesh::Vertex {
|
|
position: [0.0, -0.5, 0.0],
|
|
tan_frame: 0,
|
|
},
|
|
];
|
|
|
|
let example_vertices = AttrBuffer {
|
|
id: mesh_pass.get_vertex_attr_id(),
|
|
count: example_vertices.len(),
|
|
data: bytemuck::cast_slice(&example_vertices).to_vec(),
|
|
};
|
|
|
|
let example_indices = vec![0u32, 1u32, 2u32];
|
|
let example_indices = AttrBuffer {
|
|
id: mesh_pass.get_index_attr_id(),
|
|
count: example_indices.len(),
|
|
data: bytemuck::cast_slice(&example_indices).to_vec(),
|
|
};
|
|
|
|
let mut example_mesh = MeshBuffer::default();
|
|
example_mesh.attributes.push(example_vertices);
|
|
example_mesh.attributes.push(example_indices);
|
|
let example_mesh = mesh_pass.get_mesh_pool().load(example_mesh).unwrap();
|
|
|
|
let meshes = mesh_pass.get_meshes().to_owned();
|
|
|
|
let r = 8;
|
|
let mut meshes_lock = meshes.write();
|
|
for x in -r..r {
|
|
for y in -r..r {
|
|
for z in -r..r {
|
|
let translation = glam::Vec3::new(x as f32, y as f32, z as f32);
|
|
let transform = glam::Mat4::from_translation(translation);
|
|
meshes_lock.transformed.push(cyborg::scene::TransformedMesh {
|
|
transform,
|
|
mesh: example_mesh.clone(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
drop(meshes_lock);
|
|
|
|
let frames_in_flight = renderer.get_frames_in_flight();
|
|
let mut mesh_pass = pass::RenderPassBox::new(Arc::new(mesh_pass), frames_in_flight);
|
|
let mut debug_pass = pass::RenderPassBox::new(Arc::new(debug_pass), frames_in_flight);
|
|
|
|
event_loop.run(move |event, _, control_flow| match event {
|
|
Event::RedrawRequested(_) => {
|
|
match viewport.acquire() {
|
|
Err(wgpu::SurfaceError::Lost) => viewport.resize(viewport.size),
|
|
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
|
|
Err(e) => eprintln!("error: {:?}", e),
|
|
Ok(_) => {
|
|
let mut passes: Vec<&mut dyn pass::RenderPassBoxTrait> = Vec::new();
|
|
passes.push(&mut mesh_pass);
|
|
passes.push(&mut debug_pass);
|
|
renderer.render(passes.as_mut_slice(), &viewport, &flycam.get_camera());
|
|
viewport.present();
|
|
}
|
|
}
|
|
}
|
|
Event::MainEventsCleared => {
|
|
shader_watcher.watch();
|
|
flycam.update();
|
|
window.request_redraw();
|
|
}
|
|
Event::DeviceEvent { ref event, .. } => match event {
|
|
DeviceEvent::MouseMotion { delta } => {
|
|
if is_grabbed {
|
|
flycam.process_mouse(delta.0, delta.1);
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
Event::WindowEvent {
|
|
ref event,
|
|
window_id,
|
|
} if window_id == window.id() => match event {
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(key),
|
|
state,
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
if *state == ElementState::Pressed && *key == VirtualKeyCode::Escape {
|
|
if is_grabbed {
|
|
window.set_cursor_grab(false).unwrap();
|
|
window.set_cursor_visible(true);
|
|
is_grabbed = false;
|
|
}
|
|
} else {
|
|
flycam.process_keyboard(*key, *state);
|
|
}
|
|
}
|
|
WindowEvent::MouseInput {
|
|
button: MouseButton::Left,
|
|
state: ElementState::Pressed,
|
|
..
|
|
} => {
|
|
if !is_grabbed {
|
|
window.set_cursor_grab(true).unwrap();
|
|
window.set_cursor_visible(false);
|
|
is_grabbed = true;
|
|
}
|
|
}
|
|
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
|
|
WindowEvent::Resized(physical_size) => {
|
|
viewport.resize(*physical_size);
|
|
}
|
|
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
|
|
viewport.resize(**new_inner_size);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
});
|
|
}
|