From 6cb26db63aafcf9701db09c6c31e30940cf5662c Mon Sep 17 00:00:00 2001
From: c0repwn3r <core@coredoes.dev>
Date: Tue, 11 Apr 2023 13:08:35 -0400
Subject: [PATCH] rendering traits

---
 Cargo.lock                       | 12 ++++++
 client/Cargo.toml                |  5 ++-
 client/src/lib.rs                | 69 ++++++++++++++++++++++----------
 client/src/rendering/mod.rs      | 10 +++++
 client/src/rendering/renderer.rs | 25 ++++++++++++
 client/src/rendering/texture.rs  |  0
 web/play.html                    |  2 +
 7 files changed, 99 insertions(+), 24 deletions(-)
 create mode 100644 client/src/rendering/mod.rs
 create mode 100644 client/src/rendering/renderer.rs
 create mode 100644 client/src/rendering/texture.rs

diff --git a/Cargo.lock b/Cargo.lock
index 9a2dec267d97cd1364cc9f1abd778355ec9887ff..c95a9f37ba43ee421f308f3571805ba1dd4b4d3e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -28,6 +28,17 @@ dependencies = [
  "syn 2.0.13",
 ]
 
+[[package]]
+name = "async-trait"
+version = "0.1.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.13",
+]
+
 [[package]]
 name = "async_io_stream"
 version = "0.3.3"
@@ -1052,6 +1063,7 @@ name = "starkingdoms-client"
 version = "0.1.0"
 dependencies = [
  "async-recursion",
+ "async-trait",
  "console_error_panic_hook",
  "console_log",
  "futures",
diff --git a/client/Cargo.toml b/client/Cargo.toml
index 2e1fc08c748017a2a9befe1cc91aa6ae80b91ae9..9cef67cf4d187c5c3d3beb5cd1301ad93edb0117 100644
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@@ -24,13 +24,14 @@ lazy_static = "1.4"
 markdown = "1.0.0-alpha.7" # DO NOT DOWNGRADE
 async-recursion = "1"
 console_error_panic_hook = "0.1"
+async-trait = "0.1.68"
 
 [dependencies.web-sys]
 version = "0.3.4"
 features = [
     'Document',
     'Element',
-    'HtmlElement',
-    'Node',
+    'HtmlCanvasElement',
     'Window',
+    'CanvasRenderingContext2d'
 ]
\ No newline at end of file
diff --git a/client/src/lib.rs b/client/src/lib.rs
index e8c865d7fd11e645b9cc0ad3d111fb3305db9ff9..fbf691e344f11be627750adef9fe23bf1f49bd78 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -17,62 +17,87 @@ use std::sync::RwLock;
 use async_recursion::async_recursion;
 use futures::FutureExt;
 use wasm_bindgen_futures::JsFuture;
-use web_sys::Window;
+use web_sys::{Window};
 use starkingdoms_protocol::GoodbyeReason::PingPongTimeout;
+use crate::rendering::renderer::WebRenderer;
+
 
 #[macro_use]
 pub mod macros;
 pub mod chat;
+pub mod rendering;
 
 #[wasm_bindgen]
 extern {
     pub fn alert(s: &str);
 }
 
+pub struct Client {
+    pub client_data: Option<ClientData>
+}
+
+pub struct ClientData {
+    pub state: State,
+    pub tx: SplitSink<WsStream, WsMessage>,
+    pub rx: SplitStream<WsStream>,
+    pub pong_timeout: u64
+}
+
+pub const PONG_MAX_TIMEOUT: u64 = 5;
+
+lazy_static! {
+    pub static ref CLIENT: Arc<RwLock<Client>> = Arc::new(RwLock::new(Client {
+        client_data: None,
+        renderer: None
+    }));
+}
+
+pub const MAX_CONNECTION_TRIES: i32 = 10;
+
 #[wasm_bindgen]
-pub async fn rust_init(gateway: &str, username: &str) -> Result<(), JsError> {
+pub async fn rust_init(gateway: &str, username: &str) -> Result<(), JsValue> {
     console_error_panic_hook::set_once();
 
     set_status("Starting logger...");
 
     console_log::init_with_level(Level::Debug).unwrap();
 
-
     info!("Logger setup successfully");
 
     match main(gateway, username, 1).await {
         Ok(c) => c,
         Err(e) => {
             error!("Error initializing gateway client: {}", e);
-            return Err(JsError::new(&e.to_string()));
+            return Err(JsValue::from_str(&e.to_string()));
         }
     };
 
-    info!("Gateway client set up successfully");
+    let mut client = CLIENT.write().unwrap();
 
-    Ok(())
-}
+    set_status("Initializing render subsystem...");
+    info!("Starting renderer");
 
-pub struct Client {
-    pub client_data: Option<ClientData>,
-}
+    let renderer = match WebRenderer::init().await {
+        Ok(renderer) => renderer,
+        Err(e) => {
+            error!("Error initializing WebRenderer: {}", e);
+            return Err(JsValue::from_str(&e.to_string()));
+        }
+    };
 
-pub struct ClientData {
-    pub state: State,
-    pub tx: SplitSink<WsStream, WsMessage>,
-    pub rx: SplitStream<WsStream>,
-    pub pong_timeout: u64
-}
+    client.renderer = Some(renderer);
 
-pub const PONG_MAX_TIMEOUT: u64 = 5;
+    info!("StarKingdoms client set up successfully");
 
-lazy_static! {
-    pub static ref CLIENT: Arc<RwLock<Client>> = Arc::new(RwLock::new(Client {
-        client_data: None
-    }));
+    Ok(())
 }
 
-pub const MAX_CONNECTION_TRIES: i32 = 10;
+fn draw(context: &WebGl2RenderingContext, vert_count: i32) {
+    context.clear_color(0.0, 0.0, 0.0, 1.0);
+    context.clear(WebGl2RenderingContext::COLOR_BUFFER_BIT);
+
+    context.draw_arrays(WebGl2RenderingContext::TRIANGLES, 0, vert_count);
+}
 
 #[async_recursion(?Send)]
 pub async fn main(gateway: &str, username: &str, backoff: i32) -> Result<(), Box<dyn Error>> {
diff --git a/client/src/rendering/mod.rs b/client/src/rendering/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a025096e54804ead549cd3d4ea451c2b1d193991
--- /dev/null
+++ b/client/src/rendering/mod.rs
@@ -0,0 +1,10 @@
+use std::error::Error;
+use async_trait::async_trait;
+
+pub mod renderer;
+pub mod texture;
+
+#[async_trait]
+pub trait Renderer {
+    async fn get(canvas_element_id: &str) -> Result<Self, Box<dyn Error>> where Self: Sized;
+}
\ No newline at end of file
diff --git a/client/src/rendering/renderer.rs b/client/src/rendering/renderer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7d410d5c241b086d253a2545c56e62fa0acd0978
--- /dev/null
+++ b/client/src/rendering/renderer.rs
@@ -0,0 +1,25 @@
+use std::error::Error;
+use async_trait::async_trait;
+use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
+use crate::rendering::Renderer;
+use wasm_bindgen::JsCast;
+
+pub struct WebRenderer {
+    canvas: HtmlCanvasElement,
+    context: CanvasRenderingContext2d
+}
+
+#[async_trait]
+impl Renderer for WebRenderer {
+    async fn get(canvas_element_id: &str) -> Result<Self, Box<dyn Error>> {
+        let window = web_sys::window().ok_or("window needs to exist")?;
+        let document = window.document().ok_or("window.document needs to exist")?;
+        let canvas_element = document.get_element_by_id(canvas_element_id).ok_or("canvas element does not exist")?;
+        let typed_canvas_element: HtmlCanvasElement = canvas_element.dyn_into::<web_sys::HtmlCanvasElement>().map_err(|_| ()).unwrap();
+        let context = typed_canvas_element.get_context("2d").unwrap().unwrap().dyn_into::<CanvasRenderingContext2d>().unwrap();
+        Ok(Self {
+            canvas: typed_canvas_element,
+            context
+        })
+    }
+}
\ No newline at end of file
diff --git a/client/src/rendering/texture.rs b/client/src/rendering/texture.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/web/play.html b/web/play.html
index ee3310022d133575441a7c553df144b52d60b511..99e9afbda8d753baa43bdedc08d44a636385d4de 100644
--- a/web/play.html
+++ b/web/play.html
@@ -18,6 +18,8 @@
             <p id="status">Loading WASM module...</p>
         </div>
 
+        <canvas style="width: 100%; height: 100%" id="canvas"></canvas>
+
         <script type="module">
             // If you're getting build errors here | you need to run `just build_client_bundle` first, to compile client code
             //                                     v