summaryrefslogtreecommitdiffstats
path: root/src/main.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/main.rs')
-rw-r--r--src/main.rs204
1 files changed, 0 insertions, 204 deletions
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 3ce4ffc..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-mod osc;
-mod renderer;
-mod uniform;
-mod window;
-
-use std::sync::Arc;
-
-use osc::{OscCommand, OscServer};
-use renderer::Renderer;
-use window::{PreviewWindow, ScaleMode};
-
-use winit::application::ApplicationHandler;
-use winit::event::{ElementState, KeyEvent, WindowEvent};
-use winit::event_loop::EventLoop;
-use winit::keyboard::{Key, NamedKey};
-
-struct AppState {
- device: wgpu::Device,
- queue: wgpu::Queue,
- renderer: Renderer,
- preview: PreviewWindow,
-}
-
-struct App {
- width: u32,
- height: u32,
- scale_mode: ScaleMode,
- osc: OscServer,
- state: Option<AppState>,
-}
-
-impl App {
- fn handle_osc(&mut self) {
- let state = self.state.as_mut().expect("gpu not initialized");
- self.osc.poll(|cmd| match cmd {
- OscCommand::Shader(source) => {
- if let Err(e) = state.renderer.load_shader(&state.device, &source) {
- log::error!("shader error: {}", e);
- }
- }
- OscCommand::Uniform { path, args } => {
- if let Err(e) = state.renderer.set_uniform(&path, &args) {
- log::warn!("uniform error: {}", e);
- }
- }
- });
- }
-}
-
-impl ApplicationHandler for App {
- fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
- let window = Arc::new(
- event_loop
- .create_window(
- winit::window::Window::default_attributes()
- .with_title("wgsl-view")
- .with_inner_size(winit::dpi::LogicalSize::new(self.width, self.height)),
- )
- .expect("create window"),
- );
-
- let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
- backends: wgpu::Backends::VULKAN,
- flags: wgpu::InstanceFlags::default(),
- backend_options: wgpu::BackendOptions::default(),
- memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),
- display: None,
- });
-
- let surface = instance
- .create_surface(window.clone())
- .expect("create surface");
-
- let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
- power_preference: wgpu::PowerPreference::HighPerformance,
- compatible_surface: Some(&surface),
- force_fallback_adapter: false,
- }))
- .expect("find adapter");
-
- let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
- label: Some("device"),
- required_features: wgpu::Features::empty(),
- required_limits: wgpu::Limits::default(),
- ..Default::default()
- }))
- .expect("create device");
-
- let surface_caps = surface.get_capabilities(&adapter);
- let surface_format = surface_caps
- .formats
- .iter()
- .find(|f| f.is_srgb())
- .copied()
- .unwrap_or(surface_caps.formats[0]);
-
- let renderer = Renderer::new(&device, &queue, self.width, self.height);
- let preview = PreviewWindow::new(
- &device,
- window,
- surface,
- surface_format,
- renderer.canvas_view(),
- self.width,
- self.height,
- self.scale_mode,
- );
-
- self.state = Some(AppState {
- device,
- queue,
- renderer,
- preview,
- });
- }
-
- fn window_event(
- &mut self,
- event_loop: &winit::event_loop::ActiveEventLoop,
- _window_id: winit::window::WindowId,
- event: WindowEvent,
- ) {
- let state = self.state.as_mut().expect("gpu not initialized");
-
- match event {
- WindowEvent::CloseRequested => event_loop.exit(),
- WindowEvent::KeyboardInput {
- event:
- KeyEvent {
- logical_key,
- state: ElementState::Pressed,
- ..
- },
- ..
- } => match logical_key {
- Key::Named(NamedKey::Escape) => event_loop.exit(),
- Key::Character(ref c) if c.as_str() == "c" => {
- state.preview.scale_mode = state.preview.scale_mode.cycle();
- log::info!("scale mode: {:?}", state.preview.scale_mode);
- }
- _ => {}
- },
- WindowEvent::Resized(size) => {
- state.preview.resize(&state.device, size.width, size.height);
- }
- WindowEvent::RedrawRequested => {
- self.handle_osc();
- let state = self.state.as_mut().expect("gpu not initialized");
- state.renderer.render(&state.device, &state.queue);
- state.preview.draw(&state.device, &state.queue);
- }
- _ => {}
- }
- }
-
- fn about_to_wait(&mut self, _event_loop: &winit::event_loop::ActiveEventLoop) {
- if let Some(ref state) = self.state {
- state.preview.window().request_redraw();
- }
- }
-}
-
-fn main() {
- env_logger::init();
-
- let mut args = std::env::args().skip(1);
- let mut width = 1920u32;
- let mut height = 1080u32;
- let mut scale_mode = ScaleMode::Contain;
- let mut port = 9000u16;
-
- while let Some(arg) = args.next() {
- match arg.as_str() {
- "--width" => width = args.next().expect("--width VALUE").parse().expect("u32"),
- "--height" => height = args.next().expect("--height VALUE").parse().expect("u32"),
- "--port" => port = args.next().expect("--port VALUE").parse().expect("u16"),
- "--scale" => {
- scale_mode = match args.next().expect("--scale VALUE").as_str() {
- "contain" => ScaleMode::Contain,
- "cover" => ScaleMode::Cover,
- "center" => ScaleMode::Center,
- "natural" => ScaleMode::Natural,
- s => panic!("unknown scale mode: {}", s),
- }
- }
- other => panic!("unknown argument: {}", other),
- }
- }
-
- let osc = OscServer::new(&format!("0.0.0.0:{}", port)).expect("bind OSC socket");
-
- let event_loop = EventLoop::new().expect("create event loop");
- event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
-
- let mut app = App {
- width,
- height,
- scale_mode,
- osc,
- state: None,
- };
-
- event_loop.run_app(&mut app).expect("run");
-}