a

3 files changed, 57 insertions, 36 deletions

diff --git a/shared/src/packets.rs b/shared/src/packets.rs
index c480ba8..c273028 100644
--- a/shared/src/packets.rs
+++ b/shared/src/packets.rs
@@ -19,6 +19,12 @@ pub enum Packet {
     Sound(Object, Vec<u8>),
 }
 
+impl Object {
+    pub fn new() -> Self {
+        Self(rand::random())
+    }
+}
+
 impl Packet {
     pub fn serialize(&self, w: &mut impl Write) -> Result<()> {
         match self {
diff --git a/shared/src/resources.rs b/shared/src/resources.rs
index c54d10b..651eb4b 100644
--- a/shared/src/resources.rs
+++ b/shared/src/resources.rs
@@ -18,8 +18,10 @@ pub struct Part {
     pub texture: Option<Resource>,
 }
 
-pub struct VertexAttributes(Vec<f32>);
-pub struct Indecies(Vec<[u16; 3]>);
+#[derive(Debug, Default, Clone)]
+pub struct VertexAttributes(pub Vec<f32>);
+#[derive(Debug, Default, Clone)]
+pub struct Indecies(pub Vec<[u16; 3]>);
 
 impl Prefab {
     pub fn serialize(&self, w: &mut Vec<u8>) -> Result<()> {
@@ -69,28 +71,28 @@ impl VertexAttributes {
 impl Part {
     pub fn serialize(&self, w: &mut Vec<u8>) -> Result<()> {
         for x in &self.vertex {
-            write_kv(w, b"vertex", &x.0)?;
+            write_kv(w, b"vertex", &x.0);
         }
         if let Some(x) = &self.index {
-            write_kv(w, b"index", &x.0)?;
+            write_kv(w, b"index", &x.0);
         }
         if let Some(x) = &self.armature {
-            write_kv(w, b"armature", &x.0)?;
+            write_kv(w, b"armature", &x.0);
         }
         if let Some(x) = &self.fragment_shader {
-            write_kv(w, b"fragment_shader", &x.0)?;
+            write_kv(w, b"fragment_shader", &x.0);
         }
         if let Some(x) = &self.fragment_shader_data {
-            write_kv(w, b"fragment_shader_data", &x.0)?;
+            write_kv(w, b"fragment_shader_data", &x.0);
         }
         if let Some(x) = &self.vertex_shader {
-            write_kv(w, b"vertex_shader", &x.0)?;
+            write_kv(w, b"vertex_shader", &x.0);
         }
         if let Some(x) = &self.vertex_shader_data {
-            write_kv(w, b"vertex_shader_data", &x.0)?;
+            write_kv(w, b"vertex_shader_data", &x.0);
         }
         if let Some(x) = &self.texture {
-            write_kv(w, b"texture", &x.0)?;
+            write_kv(w, b"texture", &x.0);
         }
         Ok(())
     }
@@ -132,10 +134,9 @@ fn read_kv(r: &mut &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {
     r.read_exact(&mut key)?;
     Ok((key, value))
 }
-fn write_kv(w: &mut Vec<u8>, key: &[u8], value: &[u8]) -> Result<()> {
-    w.write_all(&(key.len() as u16).to_be_bytes())?;
-    w.write_all(&(value.len() as u16).to_be_bytes())?;
-    w.write_all(key)?;
-    w.write_all(value)?;
-    Ok(())
+fn write_kv(w: &mut Vec<u8>, key: &[u8], value: &[u8]) {
+    w.extend(&(key.len() as u16).to_be_bytes());
+    w.extend(&(value.len() as u16).to_be_bytes());
+    w.extend(key);
+    w.extend(value);
 }
diff --git a/shared/src/store.rs b/shared/src/store.rs
index 44e5e3d..7130021 100644
--- a/shared/src/store.rs
+++ b/shared/src/store.rs
@@ -2,35 +2,49 @@ use crate::packets::Resource;
 use anyhow::Result;
 use redb::{Database, TableDefinition};
 use sha2::{Digest, Sha256};
-use std::path::Path;
+use std::{collections::HashMap, path::Path, sync::Mutex};
 
 const T_ENTRIES: TableDefinition<[u8; 32], &[u8]> = TableDefinition::new("e");
 
-pub struct ResourceStore {
-    db: Database,
+pub enum ResourceStore {
+    Redb(Database),
+    Memory(Mutex<HashMap<Resource, Vec<u8>>>),
 }
 impl ResourceStore {
-    pub fn new(path: &Path) -> Result<Self> {
-        Ok(Self {
-            db: Database::create(path)?,
-        })
+    pub fn new_persistent(path: &Path) -> Result<Self> {
+        Ok(Self::Redb(Database::create(path)?))
+    }
+    pub fn new_memory() -> Self {
+        Self::Memory(HashMap::new().into())
     }
     pub fn get(&self, key: Resource) -> Result<Option<Vec<u8>>> {
-        let txn = self.db.begin_read()?;
-        let ent = txn.open_table(T_ENTRIES)?;
-        match ent.get(key.0)? {
-            Some(x) => Ok(Some(x.value().to_vec())),
-            None => Ok(None),
+        match self {
+            ResourceStore::Redb(database) => {
+                let txn = database.begin_read()?;
+                let ent = txn.open_table(T_ENTRIES)?;
+                match ent.get(key.0)? {
+                    Some(x) => Ok(Some(x.value().to_vec())),
+                    None => Ok(None),
+                }
+            }
+            ResourceStore::Memory(map) => Ok(map.lock().unwrap().get(&key).map(|x| x.to_vec())),
         }
     }
-    pub fn set(&self, value: &[u8]) -> Result<()> {
-        let key = sha256(value);
-        let txn = self.db.begin_write()?;
-        let mut ent = txn.open_table(T_ENTRIES)?;
-        ent.insert(key, value)?;
-        drop(ent);
-        txn.commit()?;
-        Ok(())
+    pub fn set(&self, value: &[u8]) -> Result<Resource> {
+        let key = Resource(sha256(value));
+        match self {
+            ResourceStore::Redb(database) => {
+                let txn = database.begin_write()?;
+                let mut ent = txn.open_table(T_ENTRIES)?;
+                ent.insert(key.0, value)?;
+                drop(ent);
+                txn.commit()?;
+            }
+            ResourceStore::Memory(map) => {
+                map.lock().unwrap().insert(key, value.to_vec());
+            }
+        }
+        Ok(key)
     }
 }