feat: ✨ draw window, since windows are rectangle we're good

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "draw_rectangle"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio = { version = "1.43.0", features = ["full"] }
+wgpu = "24.0.1"
+winit = "0.30.9"

src/drawing.rs

@@ -0,0 +1,132 @@
+use std::sync::Arc;
+
+use wgpu::{
+    Backends, Color, CompositeAlphaMode, Device, DeviceDescriptor, Features, Instance,
+    InstanceDescriptor, Limits, LoadOp, Operations, PowerPreference, PresentMode, Queue,
+    RenderPassColorAttachment, RenderPassDescriptor, RequestAdapterOptions, StoreOp, Surface,
+    SurfaceConfiguration, TextureFormat, TextureUsages, TextureViewDescriptor,
+};
+use winit::{dpi::PhysicalSize, window::Window};
+
+#[derive(Debug)]
+pub struct State {
+    surface: Surface<'static>,
+    device: Device,
+    queue: Queue,
+    surface_format: TextureFormat,
+    size: PhysicalSize<u32>,
+    window: Arc<Window>,
+}
+
+impl State {
+    pub async fn new(window: Arc<Window>) -> Self {
+        let size = window.inner_size();
+
+        let instance = Instance::new(&InstanceDescriptor {
+            backends: Backends::all(),
+            ..Default::default()
+        });
+
+        let surface = instance.create_surface(window.clone()).unwrap();
+
+        let adapter = instance
+            .request_adapter(&RequestAdapterOptions {
+                power_preference: PowerPreference::default(),
+                force_fallback_adapter: false,
+                compatible_surface: Some(&surface),
+            })
+            .await
+            .unwrap();
+
+        let (device, queue) = adapter
+            .request_device(
+                &DeviceDescriptor {
+                    label: None,
+                    required_features: Features::empty(),
+                    required_limits: Limits::default(),
+                    memory_hints: Default::default(),
+                },
+                None,
+            )
+            .await
+            .unwrap();
+        let surface_capabilities = surface.get_capabilities(&adapter);
+
+        let surface_format = surface_capabilities
+            .formats
+            .iter()
+            .find(|texture_format| texture_format.is_srgb())
+            .copied()
+            .unwrap_or(*surface_capabilities.formats.get(0).unwrap());
+
+        let state = Self {
+            surface,
+            device,
+            queue,
+            size,
+            window,
+            surface_format,
+        };
+
+        state.surface_configure();
+
+        state
+    }
+
+    fn surface_configure(&self) {
+        let surface_config = SurfaceConfiguration {
+            usage: TextureUsages::RENDER_ATTACHMENT,
+            format: self.surface_format,
+            width: self.size.width,
+            height: self.size.height,
+            present_mode: PresentMode::Immediate,
+            desired_maximum_frame_latency: 2,
+            alpha_mode: CompositeAlphaMode::Auto,
+            view_formats: vec![],
+        };
+
+        self.surface.configure(&self.device, &surface_config);
+    }
+
+    pub fn get_window(&self) -> &Window {
+        &self.window
+    }
+
+    pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
+        self.size = new_size;
+
+        self.surface_configure();
+    }
+
+    pub fn render(&mut self) {
+        let surface_texture = self.surface.get_current_texture().unwrap();
+        let texture_view = surface_texture.texture.create_view(&TextureViewDescriptor {
+            format: Some(self.surface_format.add_srgb_suffix()),
+            ..Default::default()
+        });
+
+        let mut encoder = self.device.create_command_encoder(&Default::default());
+
+        let renderpass = encoder.begin_render_pass(&RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(RenderPassColorAttachment {
+                view: &texture_view,
+                resolve_target: None,
+                ops: Operations {
+                    load: LoadOp::Clear(Color::WHITE),
+                    store: StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
+        });
+
+        // here draw
+
+        drop(renderpass);
+        self.queue.submit([encoder.finish()]);
+        self.window.pre_present_notify();
+        surface_texture.present();
+    }
+}

src/lib.rs

@@ -0,0 +1,2 @@
+pub mod drawing;
+pub mod windowing;

src/main.rs

@@ -0,0 +1,7 @@
+use draw_rectangle::windowing::run;
+
+fn main() {
+    println!("Hello, world!");
+    run();
+    println!("\n\tSuch a late goodbye");
+}

src/windowing.rs

@@ -0,0 +1,61 @@
+use std::sync::Arc;
+
+use tokio::runtime::Runtime;
+use winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
+    window::{Window, WindowId},
+};
+
+use crate::drawing::State;
+
+pub fn run() {
+    let event_loop = EventLoop::new().unwrap();
+    event_loop.set_control_flow(ControlFlow::Wait);
+
+    let mut app = App::default();
+    event_loop.run_app(&mut app).unwrap();
+}
+
+#[derive(Debug, Default)]
+pub struct App {
+    state: Option<State>,
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        let window = Arc::new(
+            event_loop
+                .create_window(Window::default_attributes())
+                .unwrap(),
+        );
+
+        let state = Runtime::new().unwrap().block_on(State::new(window.clone()));
+
+        self.state = Some(state);
+        window.request_redraw();
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        _window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        match event {
+            WindowEvent::CloseRequested => {
+                println!("Time to pack up!, See ya");
+                event_loop.exit();
+            }
+            WindowEvent::RedrawRequested => {
+                self.state.as_mut().unwrap().render();
+                self.state.as_ref().unwrap().get_window().request_redraw();
+            }
+            WindowEvent::Resized(new_size) => {
+                self.state.as_mut().unwrap().resize(new_size);
+            }
+            _ => (),
+        }
+    }
+}