refactor renderer into smaller functions

engine/src/core/render/ctx.rs

@@ -1,20 +1,133 @@
-use std::borrow::Cow;
 use std::sync::Arc;
 use std::time::Instant;
+use std::{backtrace::Backtrace, borrow::Cow};
 
 use cgmath::{Matrix4, Point3, Rad, Vector3, perspective};
 use futures::executor::block_on;
 use thiserror::Error;
+use tracing::{error, trace};
+use wgpu::TextureUsages;
 use wgpu::{Backends, InstanceDescriptor, util::DeviceExt};
 use winit::window::Window;
-
 #[derive(Debug, Error)]
-pub enum ContextError {
-    #[error("Failed to create WGPU surface: {0}")]
-    SurfaceCreationFailure(#[from] wgpu::CreateSurfaceError),
+#[error(transparent)]
+pub enum ContextErrorKind {
+    #[error("Surface creation failed")]
+    SurfaceCreation,
+    #[error("Surface configuration failed")]
+    SurfaceConfiguration,
+    #[error("Adapter request failed")]
+    AdapterRequest,
+    #[error("Device request failed")]
+    DeviceRequest,
+    #[error("Surface texture acquisition failed")]
+    SurfaceTexture,
 }
 
-const CUBE_SHADER: &str = r#"
+#[derive(Debug, Error)]
+pub struct RenderContextError {
+    kind: ContextErrorKind,
+    label: Option<Cow<'static, str>>,
+    #[source]
+    source: Option<Box<dyn std::error::Error + Send + Sync>>,
+}
+
+impl RenderContextError {
+    pub fn new(
+        kind: ContextErrorKind,
+        label: impl Into<Option<Cow<'static, str>>>,
+        source: impl Into<Option<Box<dyn std::error::Error + Send + Sync>>>,
+    ) -> Self {
+        Self {
+            kind,
+            label: label.into(),
+            source: source.into(),
+        }
+    }
+
+    pub fn with_label(mut self, label: impl Into<Cow<'static, str>>) -> Self {
+        self.label = Some(label.into());
+        self
+    }
+}
+
+impl std::fmt::Display for RenderContextError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(label) = &self.label {
+            writeln!(f, "[{}] {}", label, self.kind)?;
+        } else {
+            writeln!(f, "{}", self.kind)?;
+        }
+
+        if let Some(source) = &self.source {
+            fn fmt_chain(
+                err: &(dyn std::error::Error + 'static),
+                indent: usize,
+                f: &mut std::fmt::Formatter<'_>,
+            ) -> std::fmt::Result {
+                let indent_str = "  ".repeat(indent);
+                writeln!(f, "{}{}", indent_str, err)?;
+                if let Some(next) = err.source() {
+                    writeln!(f, "{}Caused by:", indent_str)?;
+                    fmt_chain(next, indent + 1, f)?;
+                }
+                Ok(())
+            }
+            writeln!(f, "Caused by:")?;
+            fmt_chain(source.as_ref(), 1, f)?;
+        }
+        Ok(())
+    }
+}
+
+trait IntoRenderContextError<T> {
+    fn ctx_err(
+        self,
+        kind: ContextErrorKind,
+        label: impl Into<Cow<'static, str>>,
+    ) -> Result<T, RenderContextError>;
+}
+
+impl<T, E> IntoRenderContextError<T> for Result<T, E>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    fn ctx_err(
+        self,
+        kind: ContextErrorKind,
+        label: impl Into<Cow<'static, str>>,
+    ) -> Result<T, RenderContextError> {
+        self.map_err(|e| {
+            RenderContextError::new(
+                kind,
+                Some(label.into()),
+                Some(Box::new(e) as Box<dyn std::error::Error + Send + Sync>),
+            )
+        })
+    }
+}
+
+impl From<wgpu::CreateSurfaceError> for RenderContextError {
+    fn from(err: wgpu::CreateSurfaceError) -> Self {
+        RenderContextError::new(
+            ContextErrorKind::SurfaceCreation,
+            Some("Surface creation".into()),
+            Some(Box::new(err) as Box<dyn std::error::Error + Send + Sync>),
+        )
+    }
+}
+
+impl From<wgpu::RequestDeviceError> for RenderContextError {
+    fn from(err: wgpu::RequestDeviceError) -> Self {
+        RenderContextError::new(
+            ContextErrorKind::DeviceRequest,
+            Some("Device setup".into()),
+            Some(Box::new(err) as Box<dyn std::error::Error + Send + Sync>),
+        )
+    }
+}
+
+const CUBE_SHADER: &str = r"
 struct Uniforms {
     mvp: mat4x4<f32>,
 };
@@ -40,14 +153,17 @@ fn vs_main(input: VertexInput) -> VertexOutput {
     return output;
 }
 
+
 @fragment
 fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let ambient: f32 = 0.2;
     let light_dir = normalize(vec3<f32>(0.5, 1.0, 0.5));
-    let brightness = clamp(dot(normalize(input.normal), light_dir), 0.0, 1.0);
+    let diffuse = clamp(dot(normalize(input.normal), light_dir), 0.0, 1.0);
+    // Mix ambient light to ensure no face is completely dark.
+    let brightness = ambient + (1.0 - ambient) * diffuse;
     return vec4<f32>(0.7 * brightness, 0.7 * brightness, 0.9 * brightness, 1.0);
 }
-"#;
-
+";
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 struct Vertex {
@@ -236,39 +352,52 @@ pub struct WgpuCtx<'window> {
     vertex_buffer: wgpu::Buffer,
     start_time: Instant,
     bg_color: wgpu::Color,
+    last_frame_instant: Instant,
+    frame_count: u32,
 }
 
 impl<'window> WgpuCtx<'window> {
-    pub async fn new(window: Arc<Window>) -> Result<WgpuCtx<'window>, ContextError> {
+    pub async fn new(window: Arc<Window>) -> Result<WgpuCtx<'window>, RenderContextError> {
         let instance = wgpu::Instance::new(&InstanceDescriptor {
             backends: Backends::from_comma_list("dx12,metal,opengl,webgpu"),
             ..Default::default()
         });
-        let surface = instance.create_surface(Arc::clone(&window))?;
+
+        let surface = instance
+            .create_surface(Arc::clone(&window))
+            .ctx_err(ContextErrorKind::SurfaceCreation, "Surface initialization")?;
+
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
                 power_preference: wgpu::PowerPreference::default(),
-                force_fallback_adapter: false,
                 compatible_surface: Some(&surface),
+                ..Default::default()
             })
             .await
-            .expect("Failed to obtain render adapter");
+            .ok_or_else(|| {
+                RenderContextError::new(
+                    ContextErrorKind::AdapterRequest,
+                    Some("Adapter selection".into()),
+                    None,
+                )
+            })?;
         let (device, queue) = adapter
-            .request_device(
-                &wgpu::DeviceDescriptor {
-                    label: None,
-                    required_features: wgpu::Features::empty(),
-                    required_limits: wgpu::Limits::default().using_resolution(adapter.limits()),
-                    memory_hints: wgpu::MemoryHints::Performance,
-                },
-                None,
-            )
+            .request_device(&wgpu::DeviceDescriptor::default(), None)
             .await
-            .expect("Failed to create rendering device");
+            .ctx_err(ContextErrorKind::DeviceRequest, "Device configuration")?;
         let size = window.inner_size();
         let width = size.width.max(1);
         let height = size.height.max(1);
-        let surface_config = surface.get_default_config(&adapter, width, height).unwrap();
+        let surface_config = wgpu::SurfaceConfiguration {
+            width: width.max(1),
+            height: height.max(1),
+            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            present_mode: wgpu::PresentMode::AutoNoVsync,
+            alpha_mode: wgpu::CompositeAlphaMode::Auto,
+            view_formats: Vec::new(),
+            usage: TextureUsages::RENDER_ATTACHMENT,
+            desired_maximum_frame_latency: 3,
+        };
         surface.configure(&device, &surface_config);
         let uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Uniform Buffer"),
@@ -356,10 +485,12 @@ impl<'window> WgpuCtx<'window> {
                 a: 1.0,
             },
             start_time: Instant::now(),
+            last_frame_instant: Instant::now(),
+            frame_count: 0,
         })
     }
 
-    pub fn new_blocking(window: Arc<Window>) -> Result<WgpuCtx<'window>, ContextError> {
+    pub fn new_blocking(window: Arc<Window>) -> Result<WgpuCtx<'window>, RenderContextError> {
         block_on(Self::new(window))
     }
 
@@ -431,6 +562,15 @@ impl<'window> WgpuCtx<'window> {
         }
         self.queue.submit(Some(encoder.finish()));
         surface_texture.present();
+
+        self.frame_count += 1;
+        let elapsed_secs = self.last_frame_instant.elapsed().as_secs_f32();
+        if elapsed_secs >= 1.0 {
+            let fps = self.frame_count as f32 / elapsed_secs;
+            trace!("FPS: {:.2}", fps);
+            self.frame_count = 0;
+            self.last_frame_instant = Instant::now();
+        }
     }
 
     pub fn change_bg_color(&mut self, color: wgpu::Color) {

engine/src/core/render/mod.rs

@@ -1,19 +1,29 @@
 use std::collections::HashMap;
+use std::ops::Deref;
 use std::sync::Arc;
 
 use ctx::WgpuCtx;
 use tracing::{debug, error, info, trace, warn};
+use wgpu::rwh::HasWindowHandle;
 use winit::application::ApplicationHandler;
-use winit::event::WindowEvent;
-use winit::event_loop::ControlFlow;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
-use winit::window::{Window, WindowId};
+use winit::event::{KeyEvent, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::window::Window;
+use winit::window::WindowId;
+
 pub mod ctx;
 
 struct WindowContext<'window> {
     window: Arc<Window>,
     ctx: WgpuCtx<'window>,
-    main_window: bool
+    main_window: bool,
+}
+impl Deref for WindowContext<'_> {
+    type Target = winit::window::Window;
+
+    fn deref(&self) -> &Self::Target {
+        self.window.as_ref()
+    }
 }
 impl WindowContext<'_> {
     pub fn is_main_window(&self) -> bool {
@@ -26,25 +36,155 @@ pub struct App<'window> {
     windows: HashMap<WindowId, WindowContext<'window>>,
 }
 
+impl App<'_> {
+    fn create_main_window(&mut self, event_loop: &ActiveEventLoop) {
+        let win_attr = Window::default_attributes().with_title("Zenyx");
+        match event_loop.create_window(win_attr) {
+            Ok(window) => {
+                let window = Arc::new(window);
+                let window_id = window.id();
+                match WgpuCtx::new_blocking(window.clone()) {
+                    Ok(wgpu_ctx) => {
+                        self.windows.insert(
+                            window_id,
+                            WindowContext {
+                                window,
+                                ctx: wgpu_ctx,
+                                main_window: true,
+                            },
+                        );
+                        info!("Main window created: {:?}", window_id);
+                    }
+                    Err(e) => error!("Failed to create WGPU context: {:?}", e),
+                }
+            }
+            Err(e) => error!("Failed to create main window: {:?}", e),
+        }
+    }
+
+    fn handle_close_requested(&mut self, window_id: WindowId) {
+        if self.windows.remove(&window_id).is_some() {
+            debug!("Window {:?} closed", window_id);
+        } else {
+            warn!("Tried to close non-existent window {:?}", window_id);
+        }
+    }
+
+    fn handle_keyboard_input(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        key_event: KeyEvent,
+    ) {
+        if !key_event.state.is_pressed() {
+            return;
+        }
+        match key_event.physical_key {
+            winit::keyboard::PhysicalKey::Code(code) => match code {
+                winit::keyboard::KeyCode::Space => {
+                    self.toggle_background(window_id);
+                }
+                winit::keyboard::KeyCode::Escape => {
+                    self.spawn_child_window(event_loop);
+                }
+                other => error!("Unimplemented keycode: {:?}", other),
+            },
+            _ => debug!("Received a keyboard event with no physical key"),
+        }
+    }
+
+    fn toggle_background(&mut self, window_id: WindowId) {
+        if let Some(window_context) = self.windows.get_mut(&window_id) {
+            let current_color = window_context.ctx.bg_color();
+            let new_color = match current_color {
+                wgpu::Color::WHITE => wgpu::Color::BLACK,
+                wgpu::Color::BLACK => wgpu::Color::WHITE,
+                _ => wgpu::Color::WHITE,
+            };
+            window_context.ctx.change_bg_color(new_color);
+            debug!("Toggled background color for window {:?}", window_id);
+        } else {
+            warn!("No window context for toggling background: {:?}", window_id);
+        }
+    }
+
+    fn spawn_child_window(&mut self, event_loop: &ActiveEventLoop) {
+        if let Some(main_ctx) = self.windows.values().find(|ctx| ctx.is_main_window()) {
+            let title = format!("Zenyx - New Window {}", self.windows.len());
+            //TODO: Verify that this is safe instead of matching on it
+            let win_attr = unsafe {
+                let base = Window::default_attributes().with_title(title);
+                match main_ctx.window_handle() {
+                    Ok(handle) => base.with_parent_window(Some(handle.as_raw())),
+                    Err(_) => base,
+                }
+            };
+            match event_loop.create_window(win_attr) {
+                Ok(window) => {
+                    let window = Arc::new(window);
+                    let window_id = window.id();
+                    match WgpuCtx::new_blocking(window.clone()) {
+                        Ok(wgpu_ctx) => {
+                            self.windows.insert(
+                                window_id,
+                                WindowContext {
+                                    window,
+                                    ctx: wgpu_ctx,
+                                    main_window: false,
+                                },
+                            );
+                            debug!("Spawned new child window: {:?}", window_id);
+                        }
+                        Err(e) => error!("Failed to create WGPU context for child window: {:?}", e),
+                    }
+                }
+                Err(e) => error!("Failed to create child window: {:?}", e),
+            }
+        } else {
+            error!("No main window found. Cannot spawn a child window.");
+        }
+    }
+
+    fn handle_redraw_requested(&mut self, window_id: WindowId) {
+        if let Some(window_context) = self.windows.get_mut(&window_id) {
+            window_context.ctx.draw();
+            window_context.request_redraw();
+            trace!(
+                "Redrew window {:?} with title: {}",
+                window_id,
+                window_context.window.title()
+            );
+        } else {
+            warn!("Received redraw for unknown window {:?}", window_id);
+        }
+    }
+
+    fn handle_resize(&mut self, window_id: WindowId, new_size: winit::dpi::PhysicalSize<u32>) {
+        if let Some(window_context) = self.windows.get_mut(&window_id) {
+            window_context.ctx.resize(new_size.into());
+            window_context.window.request_redraw();
+            debug!(
+                "Resized window {:?} to {}x{}",
+                window_id, new_size.width, new_size.height
+            );
+        } else {
+            warn!("Received resize for unknown window {:?}", window_id);
+        }
+    }
+
+    fn handle_destroyed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.windows.is_empty() || !self.windows.iter().any(|(_, ctx)| ctx.is_main_window()) {
+            self.windows.clear();
+            debug!("All main windows are closed. Exiting event loop.");
+            event_loop.exit();
+        }
+    }
+}
+
 impl ApplicationHandler for App<'_> {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         if self.windows.is_empty() {
-            let win_attr = Window::default_attributes().with_title("Zenyx");
-            let window = Arc::new(
-                event_loop
-                    .create_window(win_attr)
-                    .expect("create window err."),
-            );
-            let window_id = window.id();
-            let wgpu_ctx = WgpuCtx::new_blocking(window.clone()).unwrap();
-            self.windows.insert(
-                window_id,
-                WindowContext {
-                    window,
-                    ctx: wgpu_ctx,
-                    main_window: true,
-                },
-            );
+            self.create_main_window(event_loop);
         }
     }
 
@@ -56,88 +196,31 @@ impl ApplicationHandler for App<'_> {
     ) {
         match event {
             WindowEvent::CloseRequested => {
-                if let Some(window_context) = self.windows.remove(&window_id) {
-
-                    drop(window_context);
-                    debug!("Window: {:?} closed, exiting", window_id);
-                }
+                self.handle_close_requested(window_id);
             }
             WindowEvent::KeyboardInput {
-                device_id,
-                event,
-                is_synthetic,
-            } => match event.physical_key {
-                winit::keyboard::PhysicalKey::Code(code) => {
-                    if event.state.is_pressed() == false {
-                        return;
-                    }
-                    match code {
-                        winit::keyboard::KeyCode::Space => {
-                            debug!("Space key pressed");
-                            if let Some(window_context) = self.windows.get_mut(&window_id){
-                                match window_context.ctx.bg_color() {
-                                    wgpu::Color::WHITE => {
-                                        window_context.ctx.change_bg_color(wgpu::Color::BLACK)
-                                    }
-                                    wgpu::Color::BLACK => {
-                                        window_context.ctx.change_bg_color(wgpu::Color::WHITE)
-                                    }
-                                    _ => window_context.ctx.change_bg_color(wgpu::Color::WHITE),
-                                }
-                            }
-                        }
-                        winit::keyboard::KeyCode::Escape => {
-                            debug!("Escape key pressed, spawning new window");
-                            let win_attr = Window::default_attributes()
-                                .with_title(format!("Zenyx - New Window {}", self.windows.len()));
-                            let new_window = Arc::new(
-                                event_loop
-                                    .create_window(win_attr)
-                                    .expect("create window err."),
-                            );
-                            let window_id = new_window.id();
-                            let wgpu_ctx = WgpuCtx::new_blocking(new_window.clone()).unwrap();
-                            self.windows.insert(
-                                window_id,
-                                WindowContext {
-                                    window: new_window,
-                                    ctx: wgpu_ctx,
-                                    main_window: false,
-                                },
-                            );
-                        }
-                        _ => info!("Unimplemented keycode: {:?}", code),
-                    }
-                }
-                _ => {}
-            },
-            WindowEvent::RedrawRequested => {
-                if let Some(window_context) = self.windows.get_mut(&window_id) {
-                    window_context.ctx.draw();
-                    window_context.window.request_redraw();
-                }
+                event: key_event, ..
+            } => {
+                self.handle_keyboard_input(event_loop, window_id, key_event);
             }
-            WindowEvent::Resized(size) => {
-                if let Some(window_context) = self.windows.get_mut(&window_id) {
-                    window_context.ctx.resize(size.into());
-                    window_context.window.request_redraw();
-                    let size_str: String = size.height.to_string() + "x" + &size.width.to_string();
-                    debug!("Window resized to {:?}", size_str);
-                }
+            WindowEvent::RedrawRequested => {
+                self.handle_redraw_requested(window_id);
+            }
+            WindowEvent::Resized(new_size) => {
+                self.handle_resize(window_id, new_size);
             }
             WindowEvent::Destroyed => {
-                if  !self.windows.iter().any(|(_,ctx)| ctx.is_main_window()) || self.windows.is_empty() {
-                    self.windows.clear();
-                    event_loop.exit();
-                }
+                self.handle_destroyed(event_loop);
             }
-            _ => trace!("Unhandled window event"),
+            _ => trace!("Unhandled window event for window {:?}", window_id),
         }
     }
 }
 
 pub fn init_renderer(event_loop: EventLoop<()>) {
-    event_loop.set_control_flow(ControlFlow::Poll);
+    event_loop.set_control_flow(ControlFlow::Wait);
     let mut app = App::default();
-    event_loop.run_app(&mut app).unwrap();
+    if let Err(e) = event_loop.run_app(&mut app) {
+        error!("Failed to run application: {:?}", e);
+    }
 }

engine/src/main.rs

@@ -45,7 +45,6 @@ async fn main() -> anyhow::Result<()> {
     info!("Type 'help' for a list of commands.");
 
     core::render::init_renderer(event_loop);
-
     if let Err(_) = repl_thread.join() {
         eprintln!("REPL thread panicked");
     }