107 lines
3.4 KiB
Rust
107 lines
3.4 KiB
Rust
use cyborg::{pass, Renderer};
|
|
use std::sync::Arc;
|
|
use winit::{
|
|
event::*,
|
|
event_loop::{ControlFlow, EventLoop},
|
|
window::WindowBuilder,
|
|
};
|
|
|
|
struct SurfaceViewport {
|
|
device: Arc<wgpu::Device>,
|
|
size: winit::dpi::PhysicalSize<u32>,
|
|
surface: wgpu::Surface,
|
|
config: wgpu::SurfaceConfiguration,
|
|
}
|
|
|
|
impl SurfaceViewport {
|
|
fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
|
|
if new_size.width > 0 && new_size.height > 0 {
|
|
self.size = new_size;
|
|
self.config.width = new_size.width;
|
|
self.config.height = new_size.height;
|
|
self.surface.configure(&self.device, &self.config);
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn make_window_renderer(window: &winit::window::Window) -> (Renderer, SurfaceViewport) {
|
|
let size = window.inner_size();
|
|
let instance = wgpu::Instance::new(wgpu::Backends::all());
|
|
let surface = unsafe { instance.create_surface(window) };
|
|
let adapter = instance
|
|
.request_adapter(&wgpu::RequestAdapterOptions {
|
|
power_preference: wgpu::PowerPreference::LowPower,
|
|
compatible_surface: Some(&surface),
|
|
force_fallback_adapter: false,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let (device, queue) = adapter
|
|
.request_device(
|
|
&wgpu::DeviceDescriptor {
|
|
features: wgpu::Features::empty(),
|
|
limits: wgpu::Limits::default(),
|
|
label: None,
|
|
},
|
|
None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let config = wgpu::SurfaceConfiguration {
|
|
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
|
format: surface.get_preferred_format(&adapter).unwrap(),
|
|
width: size.width,
|
|
height: size.height,
|
|
present_mode: wgpu::PresentMode::Fifo,
|
|
};
|
|
surface.configure(&device, &config);
|
|
|
|
let device = Arc::new(device);
|
|
let renderer = Renderer::new(device.clone(), queue);
|
|
let viewport = SurfaceViewport {
|
|
device,
|
|
size,
|
|
surface,
|
|
config,
|
|
};
|
|
(renderer, viewport)
|
|
}
|
|
|
|
fn main() {
|
|
let event_loop = EventLoop::new();
|
|
let window = WindowBuilder::new().build(&event_loop).unwrap();
|
|
let (mut renderer, mut viewport) = pollster::block_on(make_window_renderer(&window));
|
|
|
|
let device = renderer.get_device();
|
|
let mesh_pass = pass::mesh::MeshPass::new(device.to_owned(), viewport.config.format);
|
|
renderer.add_pass(mesh_pass);
|
|
|
|
event_loop.run(move |event, _, control_flow| match event {
|
|
Event::RedrawRequested(_) => {
|
|
match renderer.render(&viewport.surface, viewport.config.format) {
|
|
Ok(_) => {}
|
|
Err(wgpu::SurfaceError::Lost) => viewport.resize(viewport.size),
|
|
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
|
|
Err(e) => eprintln!("error: {:?}", e),
|
|
};
|
|
}
|
|
Event::MainEventsCleared => {
|
|
window.request_redraw();
|
|
}
|
|
Event::WindowEvent {
|
|
ref event,
|
|
window_id,
|
|
} if window_id == window.id() => match event {
|
|
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
|
|
WindowEvent::Resized(physical_size) => {
|
|
viewport.resize(*physical_size);
|
|
}
|
|
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
|
|
viewport.resize(**new_inner_size);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
});
|
|
}
|