initial commit

src/testing/app.rs

@@ -0,0 +1,36 @@
+use winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, EventLoop},
+    window::{Window, WindowId},
+};
+
+use super::Client;
+
+#[derive(Default)]
+pub struct App {
+    client: Option<Client>,
+}
+
+impl App {
+    pub fn run() {
+        let event_loop = EventLoop::new().unwrap();
+        event_loop.run_app(&mut App::default()).unwrap();
+    }
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.client.is_none() {
+            let window = event_loop
+                .create_window(Window::default_attributes())
+                .unwrap();
+            let client = Client::new(window.into());
+            self.client = Some(client);
+        }
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        self.client.as_mut().unwrap().event(event, event_loop);
+    }
+}

src/testing/mod.rs

@@ -0,0 +1,58 @@
+use std::sync::Arc;
+
+use app::App;
+use gui::{primitive::Axis, NodeArrayUtil, NodeUtil, RoundedRect, UIColor};
+use render::Renderer;
+use winit::{event::WindowEvent, event_loop::ActiveEventLoop, window::Window};
+
+mod app;
+mod render;
+
+pub fn main() {
+    App::run();
+}
+
+pub struct Client {
+    renderer: Renderer,
+}
+
+impl Client {
+    pub fn new(window: Arc<Window>) -> Self {
+        let mut renderer = Renderer::new(window);
+        let rect = RoundedRect {
+            color: UIColor::WHITE,
+            radius: 10.0,
+            thickness: 0.0,
+            inner_radius: 0.0,
+        };
+        let ui = (
+            (
+                rect.color(UIColor::BLUE),
+                (
+                    rect.color(UIColor::RED),
+                    (rect.color(UIColor::ORANGE), rect.color(UIColor::LIME))
+                        .proportioned(Axis::Y, [1, 1]),
+                    rect.color(UIColor::YELLOW),
+                )
+                    .proportioned(Axis::X, [2, 2, 1])
+                    .pad(10),
+            )
+                .proportioned(Axis::X, [1, 3]),
+            rect.color(UIColor::GREEN),
+        )
+            .proportioned(Axis::Y, [3, 1])
+            .pad(10)
+            .into();
+        renderer.update(&ui);
+        Self { renderer }
+    }
+
+    pub fn event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        match event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => self.renderer.draw(),
+            WindowEvent::Resized(size) => self.renderer.resize(&size),
+            _ => (),
+        }
+    }
+}

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,
+        }
+    }
+}