initial commit

src/testing/render/mod.rs

@@ -0,0 +1,132 @@
+use gui::{UIRenderNode, UI};
+use pollster::FutureExt;
+use std::sync::Arc;
+use wgpu::util::StagingBelt;
+use winit::{dpi::PhysicalSize, window::Window};
+
+pub const CLEAR_COLOR: wgpu::Color = wgpu::Color::BLACK;
+
+pub struct Renderer {
+    surface: wgpu::Surface<'static>,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    config: wgpu::SurfaceConfiguration,
+    encoder: wgpu::CommandEncoder,
+    staging_belt: StagingBelt,
+    ui_node: UIRenderNode,
+}
+
+impl Renderer {
+    pub fn update(&mut self, ui: &UI) {
+        self.ui_node.update(&self.device, &self.queue, ui);
+    }
+
+    pub fn draw(&mut self) {
+        let output = self.surface.get_current_texture().unwrap();
+        let view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+
+        let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device));
+        {
+            let render_pass = &mut encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(CLEAR_COLOR),
+                        store: wgpu::StoreOp::Store,
+                    },
+                    depth_slice: None,
+                })],
+                ..Default::default()
+            });
+            self.ui_node.draw(render_pass);
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        self.staging_belt.finish();
+        output.present();
+        self.staging_belt.recall();
+    }
+
+    pub fn resize(&mut self, size: &PhysicalSize<u32>) {
+        self.config.width = size.width;
+        self.config.height = size.height;
+        self.surface.configure(&self.device, &self.config);
+        self.ui_node.resize(size, &self.queue);
+    }
+
+    fn create_encoder(device: &wgpu::Device) -> wgpu::CommandEncoder {
+        device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+            label: Some("Render Encoder"),
+        })
+    }
+
+    pub fn new(window: Arc<Window>) -> Self {
+        let size = window.inner_size();
+
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::PRIMARY,
+            ..Default::default()
+        });
+
+        let surface = instance
+            .create_surface(window.clone())
+            .expect("Could not create window surface!");
+
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::default(),
+                compatible_surface: Some(&surface),
+                force_fallback_adapter: false,
+            })
+            .block_on()
+            .expect("Could not get adapter!");
+
+        let (device, queue) = adapter
+            .request_device(&wgpu::DeviceDescriptor {
+                required_features: wgpu::Features::empty(),
+                required_limits: wgpu::Limits::default(),
+                ..Default::default()
+            })
+            .block_on()
+            .expect("Could not get device!");
+
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps
+            .formats
+            .iter()
+            .copied()
+            .find(|f| f.is_srgb())
+            .unwrap_or(surface_caps.formats[0]);
+
+        let config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: size.width,
+            height: size.height,
+            present_mode: wgpu::PresentMode::AutoVsync,
+            alpha_mode: surface_caps.alpha_modes[0],
+            desired_maximum_frame_latency: 2,
+            view_formats: vec![],
+        };
+
+        surface.configure(&device, &config);
+
+        let staging_belt = StagingBelt::new(4096 * 4);
+        let encoder = Self::create_encoder(&device);
+
+        let shape_pipeline = UIRenderNode::new(&device, &config);
+
+        Self {
+            surface,
+            device,
+            queue,
+            config,
+            encoder,
+            staging_belt,
+            ui_node: shape_pipeline,
+        }
+    }
+}