added underdeveloped but working image support (no freeing or samplers)

src/testing/render/mod.rs

@@ -1,48 +1,51 @@
-use gui::{UIRenderNode, primitive::Primitives};
 use pollster::FutureExt;
 use std::sync::Arc;
-use wgpu::util::StagingBelt;
+use ui::{
+    UiRenderUpdates,
+    render::{UiLimits, UiRenderer},
+};
+use wgpu::{util::StagingBelt, *};
 use winit::{dpi::PhysicalSize, window::Window};
 
-pub const CLEAR_COLOR: wgpu::Color = wgpu::Color::BLACK;
+pub const CLEAR_COLOR: Color = Color::BLACK;
 
 pub struct Renderer {
     window: Arc<Window>,
-    surface: wgpu::Surface<'static>,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
-    config: wgpu::SurfaceConfiguration,
-    encoder: wgpu::CommandEncoder,
+    surface: Surface<'static>,
+    device: Device,
+    queue: Queue,
+    config: SurfaceConfiguration,
+    encoder: CommandEncoder,
     staging_belt: StagingBelt,
-    ui_node: UIRenderNode,
+    ui: UiRenderer,
 }
 
 impl Renderer {
-    pub fn update(&mut self, primitives: Option<&Primitives>) {
-        self.ui_node.update(&self.device, &self.queue, primitives);
+    pub fn update(&mut self, updates: UiRenderUpdates) {
+        self.ui.update(&self.device, &self.queue, updates);
     }
 
     pub fn draw(&mut self) {
         let output = self.surface.get_current_texture().unwrap();
         let view = output
             .texture
-            .create_view(&wgpu::TextureViewDescriptor::default());
+            .create_view(&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 {
+            let render_pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+                color_attachments: &[Some(RenderPassColorAttachment {
                     view: &view,
                     resolve_target: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(CLEAR_COLOR),
-                        store: wgpu::StoreOp::Store,
+                    ops: Operations {
+                        load: LoadOp::Clear(CLEAR_COLOR),
+                        store: StoreOp::Store,
                     },
                     depth_slice: None,
                 })],
                 ..Default::default()
             });
-            self.ui_node.draw(render_pass);
+            self.ui.draw(render_pass);
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
@@ -55,11 +58,11 @@ impl Renderer {
         self.config.width = size.width;
         self.config.height = size.height;
         self.surface.configure(&self.device, &self.config);
-        self.ui_node.resize(size, &self.queue);
+        self.ui.resize(size, &self.queue);
     }
 
-    fn create_encoder(device: &wgpu::Device) -> wgpu::CommandEncoder {
-        device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+    fn create_encoder(device: &Device) -> CommandEncoder {
+        device.create_command_encoder(&CommandEncoderDescriptor {
             label: Some("Render Encoder"),
         })
     }
@@ -67,8 +70,8 @@ impl Renderer {
     pub fn new(window: Arc<Window>) -> Self {
         let size = window.inner_size();
 
-        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
-            backends: wgpu::Backends::PRIMARY,
+        let instance = Instance::new(&InstanceDescriptor {
+            backends: Backends::PRIMARY,
             ..Default::default()
         });
 
@@ -77,18 +80,28 @@ impl Renderer {
             .expect("Could not create window surface!");
 
         let adapter = instance
-            .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::default(),
+            .request_adapter(&RequestAdapterOptions {
+                power_preference: PowerPreference::default(),
                 compatible_surface: Some(&surface),
                 force_fallback_adapter: false,
             })
             .block_on()
             .expect("Could not get adapter!");
 
+        let ui_limits = UiLimits::default();
+
         let (device, queue) = adapter
-            .request_device(&wgpu::DeviceDescriptor {
-                required_features: wgpu::Features::empty(),
-                required_limits: wgpu::Limits::default(),
+            .request_device(&DeviceDescriptor {
+                required_features: Features::TEXTURE_BINDING_ARRAY
+                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
+                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
+                required_limits: Limits {
+                    max_binding_array_elements_per_shader_stage: ui_limits
+                        .max_binding_array_elements_per_shader_stage(),
+                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
+                        .max_binding_array_sampler_elements_per_shader_stage(),
+                    ..Default::default()
+                },
                 ..Default::default()
             })
             .block_on()
@@ -102,12 +115,12 @@ impl Renderer {
             .find(|f| f.is_srgb())
             .unwrap_or(surface_caps.formats[0]);
 
-        let config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+        let config = SurfaceConfiguration {
+            usage: TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
             width: size.width,
             height: size.height,
-            present_mode: wgpu::PresentMode::AutoVsync,
+            present_mode: PresentMode::AutoVsync,
             alpha_mode: surface_caps.alpha_modes[0],
             desired_maximum_frame_latency: 2,
             view_formats: vec![],
@@ -118,7 +131,7 @@ impl Renderer {
         let staging_belt = StagingBelt::new(4096 * 4);
         let encoder = Self::create_encoder(&device);
 
-        let shape_pipeline = UIRenderNode::new(&device, &config);
+        let shape_pipeline = UiRenderer::new(&device, &queue, &config, ui_limits);
 
         Self {
             surface,
@@ -127,7 +140,7 @@ impl Renderer {
             config,
             encoder,
             staging_belt,
-            ui_node: shape_pipeline,
+            ui: shape_pipeline,
             window,
         }
     }