Adds Rect Deno Resouces (#4)

* arc mutex app state

* kompletter rückbau

* create react with resource id

* create & append ops

* update rect

* std_lib

* op_remove_rect

* renamend op_remove_rect_from_window

* renamed gpu mod to graphics

* updating rects from js

* lil cleanup

* wip

Author: LukasBombach

src/app.rs

@@ -4,34 +4,43 @@ use std::sync::Mutex;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
 use winit::event_loop::ActiveEventLoop;
+use winit::event_loop::EventLoopProxy;
 use winit::window::Window;
 use winit::window::WindowId;
 
-use crate::gpu::Gpu;
-use crate::gpu::Instance;
+use crate::graphics::Gpu;
+use crate::graphics::Instance;
+use crate::graphics::Rect;
 
-#[derive(Debug, Clone, Copy)]
-pub enum JsEvents {
-    AddRect(u32, u32, u32, u32),
+#[derive(Debug)]
+pub enum Js {
+    RectsUpdated,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub struct Rect(u32, u32, u32, u32);
-
 #[derive(Debug, Clone)]
 pub struct AppState {
-    rects: Vec<Rect>,
+    pub rects: Arc<Mutex<Vec<Arc<Mutex<Rect>>>>>,
+    pub event_loop: Arc<Mutex<EventLoopProxy<Js>>>,
+}
+
+impl AppState {
+    pub fn new(event_loop: Arc<Mutex<EventLoopProxy<Js>>>) -> Self {
+        Self {
+            rects: Arc::new(Mutex::new(Vec::new())),
+            event_loop,
+        }
+    }
 }
 
 pub struct App<'window> {
     window: Option<Arc<Window>>,
     gpu: Option<Gpu<'window>>,
-    state: Arc<Mutex<AppState>>,
+    pub state: Arc<Mutex<AppState>>,
 }
 
 impl App<'_> {
-    pub fn new() -> Self {
-        let state = Arc::new(Mutex::new(AppState { rects: Vec::new() }));
+    pub fn new(event_loop: Arc<Mutex<EventLoopProxy<Js>>>) -> Self {
+        let state = Arc::new(Mutex::new(AppState::new(event_loop)));
 
         Self {
             window: None,
@@ -40,50 +49,52 @@ impl App<'_> {
         }
     }
 
-    pub fn add_rect(&mut self, x: u32, y: u32, w: u32, h: u32) {
-        self.state.lock().unwrap().rects.push(Rect(x, y, w, h));
-        self.sync_gpu_instance_buffer();
-
-        if let Some(window) = self.window.as_ref() {
-            window.request_redraw();
-        }
-    }
-
     fn rects_to_instances(&self) -> Vec<Instance> {
         self.state
             .lock()
             .unwrap()
             .rects
+            .lock()
+            .unwrap()
             .iter()
-            .map(|r| Instance::new(r.0 as f32, r.1 as f32, r.2 as f32, r.3 as f32))
+            .map(|r| {
+                let rect = r.lock().unwrap();
+                Instance::new(rect.0 as f32, rect.1 as f32, rect.2 as f32, rect.3 as f32)
+            })
             .collect()
     }
-
-    fn sync_gpu_instance_buffer(&mut self) {
-        let instances = self.rects_to_instances();
-        if let Some(gpu) = self.gpu.as_mut() {
-            gpu.update_instance_buffer(&instances);
-        }
-    }
 }
 
-impl<'window> ApplicationHandler<JsEvents> for App<'window> {
+impl<'window> ApplicationHandler<Js> for App<'window> {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         if self.window.is_none() {
             let window = Arc::new(
                 event_loop
-                    .create_window(Window::default_attributes().with_title("wgpu winit example"))
+                    .create_window(
+                        Window::default_attributes()
+                            .with_position(winit::dpi::PhysicalPosition::new(100, 200))
+                            .with_title("wgpu winit example"),
+                    )
                     .expect("create window err."),
             );
 
             self.window = Some(window.clone());
-            self.gpu = Some(Gpu::new(window.clone(), self.rects_to_instances()));
+            self.gpu = Some(Gpu::new(window.clone()));
         }
     }
 
-    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: JsEvents) {
-        let JsEvents::AddRect(x, y, w, h) = event;
-        self.add_rect(x, y, w, h);
+    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: Js) {
+        match event {
+            Js::RectsUpdated => {
+                let instances = self.rects_to_instances();
+                if let Some(gpu) = self.gpu.as_mut() {
+                    gpu.update_instance_buffer(&instances);
+                }
+                if let Some(window) = self.window.as_ref() {
+                    window.request_redraw();
+                }
+            }
+        }
     }
 
     fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {

src/deno.rs

@@ -1,45 +1,141 @@
-use std::borrow::Cow;
 use std::env::current_dir;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::thread;
 
 use deno_core::error::AnyError;
+use deno_core::extension;
 use deno_core::op2;
 use deno_core::resolve_path;
-use deno_core::Extension;
 use deno_core::FsModuleLoader;
 use deno_core::JsRuntime;
-use deno_core::OpDecl;
 use deno_core::OpState;
+use deno_core::Resource;
 use deno_core::RuntimeOptions;
 
-use winit::event_loop::EventLoopProxy;
+use crate::app::AppState;
+use crate::app::Js;
+use crate::graphics::Rect;
 
-use crate::JsEvents;
+struct RectResource(Arc<Mutex<Rect>>);
+impl Resource for RectResource {}
 
 #[op2(fast)]
-fn op_add_rect(
+fn op_create_rect(
     state: &mut OpState,
     x: u32,
     y: u32,
     w: u32,
     h: u32,
+) -> Result<u32, deno_error::JsErrorBox> {
+    let rect = Arc::new(Mutex::new(Rect(x, y, w, h)));
+
+    let resource_table = &mut state.resource_table;
+    let rid = resource_table.add(RectResource(rect.clone()));
+
+    Ok(rid)
+}
+
+#[op2(fast)]
+fn op_append_rect_to_window(state: &mut OpState, rid: u32) -> Result<(), deno_error::JsErrorBox> {
+    let resource_table = &mut state.resource_table;
+    let rect_resource = resource_table.get::<RectResource>(rid).unwrap();
+    let rect = rect_resource.0.clone();
+
+    state
+        .borrow::<Arc<Mutex<AppState>>>()
+        .lock()
+        .unwrap()
+        .rects
+        .lock()
+        .unwrap()
+        .push(rect.clone());
+
+    state
+        .borrow::<Arc<Mutex<AppState>>>()
+        .lock()
+        .unwrap()
+        .event_loop
+        .lock()
+        .unwrap()
+        .send_event(Js::RectsUpdated)
+        .unwrap();
+
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_update_rect(
+    state: &mut OpState,
+    rid: u32,
+    x: u32,
+    y: u32,
+    w: u32,
+    h: u32,
 ) -> Result<(), deno_error::JsErrorBox> {
+    let resource_table = &mut state.resource_table;
+    let rect_resource = resource_table.get::<RectResource>(rid).unwrap();
+    let rect = rect_resource.0.clone();
+
+    let mut rect = rect.lock().unwrap();
+    rect.0 = x;
+    rect.1 = y;
+    rect.2 = w;
+    rect.3 = h;
+
+    state
+        .borrow::<Arc<Mutex<AppState>>>()
+        .lock()
+        .unwrap()
+        .event_loop
+        .lock()
+        .unwrap()
+        .send_event(Js::RectsUpdated)
+        .unwrap();
+
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_remove_rect_from_window(state: &mut OpState, rid: u32) -> Result<(), deno_error::JsErrorBox> {
+    let resource_table = &mut state.resource_table;
+    let rect_resource = resource_table.take::<RectResource>(rid).unwrap();
+    let rect = rect_resource.0.clone();
+
     state
-        .borrow::<Arc<Mutex<EventLoopProxy<JsEvents>>>>()
-        .clone()
+        .borrow::<Arc<Mutex<AppState>>>()
+        .lock()
+        .unwrap()
+        .rects
         .lock()
         .unwrap()
-        .send_event(JsEvents::AddRect(x, y, w, h))
+        .retain(|item| !Arc::ptr_eq(item, &rect));
+
+    state
+        .borrow::<Arc<Mutex<AppState>>>()
+        .lock()
+        .unwrap()
+        .event_loop
+        .lock()
+        .unwrap()
+        .send_event(Js::RectsUpdated)
         .unwrap();
 
     Ok(())
 }
 
-pub fn run_script(event_loop_proxy: Arc<Mutex<EventLoopProxy<JsEvents>>>, path: &str) {
-    let proxy = event_loop_proxy.clone();
+extension!(
+    rects,
+    ops = [
+        op_create_rect,
+        op_append_rect_to_window,
+        op_update_rect,
+        op_remove_rect_from_window,
+    ]
+);
+
+pub fn run_script(app_state: Arc<Mutex<AppState>>, path: &str) {
     let path = path.to_string();
 
     let _handle = thread::spawn(move || {
@@ -49,20 +145,13 @@ pub fn run_script(event_loop_proxy: Arc<Mutex<EventLoopProxy<JsEvents>>>, path:
             .unwrap();
 
         if let Err(error) = tokio_runtime.block_on(async {
-            const DECL: OpDecl = op_add_rect();
-            let ext = Extension {
-                name: "add_rect_ext",
-                ops: Cow::Borrowed(&[DECL]),
-                ..Default::default()
-            };
-
             let mut js_runtime = JsRuntime::new(RuntimeOptions {
-                extensions: vec![ext],
+                extensions: vec![rects::init_ops_and_esm()],
                 module_loader: Some(Rc::new(FsModuleLoader)),
                 ..Default::default()
             });
 
-            js_runtime.op_state().borrow_mut().put(proxy);
+            js_runtime.op_state().borrow_mut().put(app_state);
 
             let main_module = resolve_path(&path, &current_dir().unwrap()).unwrap();
             let mod_id = js_runtime.load_main_es_module(&main_module).await?;

src/gpu.rs renamed to src/graphics.rs

@@ -9,6 +9,9 @@ use wgpu::MemoryHints::Performance;
 use wgpu::ShaderSource;
 use winit::window::Window;
 
+#[derive(Copy, Clone, Debug)]
+pub struct Rect(pub u32, pub u32, pub u32, pub u32);
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable)]
 pub struct Instance {
@@ -40,11 +43,11 @@ pub struct Gpu<'window> {
 }
 
 impl<'window> Gpu<'window> {
-    pub fn new(window: Arc<Window>, instances: Vec<Instance>) -> Gpu<'window> {
-        pollster::block_on(Gpu::new_async(window, instances))
+    pub fn new(window: Arc<Window>) -> Gpu<'window> {
+        pollster::block_on(Gpu::new_async(window))
     }
 
-    pub async fn new_async(window: Arc<Window>, instances: Vec<Instance>) -> Gpu<'window> {
+    pub async fn new_async(window: Arc<Window>) -> Gpu<'window> {
         /*
          * window
          */
@@ -130,11 +133,14 @@ impl<'window> Gpu<'window> {
          * instances
          */
 
+        let instances: Vec<Instance> = Vec::new();
+
         let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             label: Some("Instance Buffer"),
             contents: cast_slice(&instances),
             usage: wgpu::BufferUsages::VERTEX,
         });
+
         let instance_count = instances.len() as u32;
 
         /*

src/main.js

@@ -1,3 +1,15 @@
-for (let i = 0; i < 10; i++) {
-  Deno.core.ops.op_add_rect(100 + i * 100, 100 + i * 70, 250, 250);
-}
+import { console, setTimeout, setInterval } from "./std.js";
+
+const create_rect = Deno.core.ops.op_create_rect;
+const update_rect = Deno.core.ops.op_update_rect;
+const append_rect_to_window = Deno.core.ops.op_append_rect_to_window;
+const op_remove_rect = Deno.core.ops.op_remove_rect;
+
+const id = create_rect(100, 100, 200, 200);
+append_rect_to_window(id);
+
+console.log(`Added rect with id: ${id}`);
+
+setTimeout(() => {
+  update_rect(id, 100, 100, 600, 600);
+}, 500);

src/main.rs

@@ -5,20 +5,19 @@ use winit::error::EventLoopError;
 use winit::event_loop::EventLoop;
 
 use crate::app::App;
-use crate::app::JsEvents;
+use crate::app::Js;
 use crate::deno::run_script;
 
 mod app;
 mod deno;
-mod gpu;
+mod graphics;
 
 fn main() -> Result<(), EventLoopError> {
-    let mut app = App::new();
+    let event_loop = EventLoop::<Js>::with_user_event().build()?;
+    let event_loop_proxy = Arc::new(Mutex::new(event_loop.create_proxy()));
+    let mut app = App::new(event_loop_proxy);
 
-    let event_loop = EventLoop::<JsEvents>::with_user_event().build()?;
-    let proxy = Arc::new(Mutex::new(event_loop.create_proxy()));
-
-    run_script(proxy, "src/main.js");
+    run_script(app.state.clone(), "src/main.js");
 
     event_loop.run_app(&mut app)
 }