PoC renderer

.gitignore

@@ -6,3 +6,5 @@ build/
 
 crates/pill_standalone/Cargo.toml
 examples/*/Cargo.toml
+
+engine/Cargo.toml

engine/.cargo/config.toml

@@ -0,0 +1,16 @@
+[build]
+# Enable SIMD optimizations for math operations
+# This will auto-vectorize cgmath operations when possible
+rustflags = ["-C", "target-cpu=native"]
+
+# Alternative: More conservative SIMD flags
+# rustflags = ["-C", "target-feature=+avx2,+fma"]
+
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "target-cpu=native"]
+
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "target-cpu=native"]
+
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-cpu=native"]

engine/Cargo.toml

@@ -3,11 +3,19 @@ resolver = "2"
 members = [
     "pill_core",
     "pill_engine",
-    "pill_renderer",
     "pill_standalone",
-    "NO_PATH", ### Game project crate (This will be changed by Pill Launcher on build to allow proper compilation of game project)
+    "/Users/mk/dev/demo/pill_demo", ### Game project crate (This will be changed by Pill Launcher on build to allow proper compilation of game project)
 ]
 
 exclude = [
     "pill_launcher",
 ]
+
+[profile.dev]
+opt-level = 3
+incremental = true
+
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1

engine/pill_core/src/handle.rs

@@ -0,0 +1,116 @@
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::marker::PhantomData;
+
+#[repr(transparent)]
+pub struct Handle<T> {
+    raw: u64,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Handle<T> {
+    #[inline]
+    pub const fn from_parts(index: u32, generation: u32) -> Self {
+        Self {
+            raw: ((generation as u64) << 32) | (index as u64),
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub const fn index(&self) -> u32 { self.raw as u32 }
+
+    #[inline]
+    pub const fn generation(&self) -> u32 { (self.raw >> 32) as u32 }
+
+    pub const INVALID: Self = Self { raw: u64::MAX, _marker: PhantomData };
+
+    #[inline]
+    pub const fn is_valid(&self) -> bool { self.raw != u64::MAX }
+}
+
+impl<T> Copy for Handle<T> {}
+impl<T> Clone for Handle<T> { fn clone(&self) -> Self { *self } }
+impl<T> PartialEq for Handle<T> { fn eq(&self, other: &Self) -> bool { self.raw == other.raw } }
+impl<T> Eq for Handle<T> {}
+impl<T> Hash for Handle<T> { fn hash<H: Hasher>(&self, state: &mut H) { self.raw.hash(state) } }
+impl<T> fmt::Debug for Handle<T> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "Handle({:#x})", self.raw) } }
+
+struct Entry<V> {
+    generation: u32,
+    resource: Option<V>,
+}
+
+pub struct ResourcePool<K, V> {
+    entries: Vec<Entry<V>>,
+    free_list: Vec<u32>,
+    _marker: PhantomData<K>,
+}
+
+impl<K, V> ResourcePool<K, V> {
+    pub fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+            free_list: Vec::new(),
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn insert(&mut self, resource: V) -> Handle<K> {
+        if let Some(idx) = self.free_list.pop() {
+            let e = &mut self.entries[idx as usize];
+            e.generation = e.generation.wrapping_add(1);
+            e.resource = Some(resource);
+            Handle::from_parts(idx, e.generation)
+        } else {
+            let idx = self.entries.len() as u32;
+            self.entries.push(Entry { generation: 0, resource: Some(resource) });
+            Handle::from_parts(idx, 0)
+        }
+    }
+
+    #[inline]
+    pub fn remove(&mut self, h: Handle<K>) -> Option<V> {
+        let idx = h.index() as usize;
+        if idx >= self.entries.len() {
+            return None;
+        }
+        let e = &mut self.entries[idx];
+        if e.generation != h.generation() {
+            return None;
+        }
+        let res = e.resource.take();
+        e.generation = e.generation.wrapping_add(1);
+        self.free_list.push(h.index());
+        res
+    }
+
+    #[inline]
+    pub fn get(&self, h: Handle<K>) -> Option<&V> {
+        let idx = h.index() as usize;
+        if idx >= self.entries.len() {
+            return None;
+        }
+        let e = &self.entries[idx];
+        if e.generation != h.generation() {
+            return None;
+        }
+        e.resource.as_ref()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, h: Handle<K>) -> Option<&mut V> {
+        let idx = h.index() as usize;
+        if idx >= self.entries.len() {
+            return None;
+        }
+        let e = &mut self.entries[idx];
+        if e.generation != h.generation() {
+            return None;
+        }
+        e.resource.as_mut()
+    }
+}
+
+

engine/pill_core/src/lib.rs

@@ -9,6 +9,8 @@ mod pill_twinmap;
 mod pill_typemap;
 mod bitmask_utils;
 mod timer;
+mod handle;
+mod tags;
 
 // --- Use ---
 
@@ -62,4 +64,19 @@ pub use utils::{
 pub use timer::{
     Timer,
     TimerRecord
+};
+
+pub use handle::{
+    Handle,
+    ResourcePool,
+};
+
+pub use tags::{
+    RendererBufferTag,
+    RendererCameraTag,
+    RendererMaterialTag,
+    RendererMeshTag,
+    RendererPipelineTag,
+    RendererPipelineV2Tag,
+    RendererTextureTag,
 };

engine/pill_core/src/pill_slotmap.rs

@@ -20,7 +20,6 @@
 
 //  3. This notice may not be removed or altered from any source distribution.
 
-
 // --- PillSlotMap
 // This is slotmap crate modified by changing names of types, adding public key variables, removing iterators and adding possibility to restrict version limit
 // Original crate: https://crates.io/crates/SlotMap
@@ -30,14 +29,14 @@
 
 //! Contains the slot map implementation.
 use core::fmt;
+use core::fmt::Debug;
 use core::marker::PhantomData;
 #[allow(unused_imports)] // MaybeUninit is only used on nightly at the moment.
 use core::mem::{ManuallyDrop, MaybeUninit};
 use core::ops::{Index, IndexMut};
 use std::fmt::Formatter;
-use core::fmt::Debug;
 use std::iter::Enumerate;
-use std::num::{ NonZeroU32};
+use std::num::NonZeroU32;
 
 // Storage inside a slot or metadata for the freelist when vacant.
 union SlotUnion<T> {
@@ -73,7 +72,7 @@ impl<T> Slot<T> {
         self.version % 2 > 0
     }
 
-    pub fn get(&self) -> SlotContent<T> {
+    pub fn get(&self) -> SlotContent<'_, T> {
         unsafe {
             if self.occupied() {
                 Occupied(&*self.u.value)
@@ -83,7 +82,7 @@ impl<T> Slot<T> {
         }
     }
 
-    pub fn get_mut(&mut self) -> SlotContentMut<T> {
+    pub fn get_mut(&mut self) -> SlotContentMut<'_, T> {
         unsafe {
             if self.occupied() {
                 OccupiedMut(&mut *self.u.value)
@@ -142,7 +141,6 @@ pub struct PillSlotMap<K: PillSlotMapKey, V> {
 }
 
 impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
-
     pub fn with_key() -> Self {
         Self::with_capacity_and_key(0)
     }
@@ -152,11 +150,14 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
     }
 
     // Warning: Version limit has to be odd value
-    pub fn with_capacity_and_key_and_version_limit(capacity: usize, version_limit: u32) -> Result<Self, ()> {
+    pub fn with_capacity_and_key_and_version_limit(
+        capacity: usize,
+        version_limit: u32,
+    ) -> Result<Self, ()> {
         if version_limit % 2 == 0 {
-            return Err(())
+            return Err(());
         }
-        
+
         let mut slots = Vec::with_capacity(capacity + 1);
         slots.push(Slot {
             u: SlotUnion { next_free: 0 },
@@ -170,7 +171,7 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
             version_limit,
             _k: PhantomData,
         };
-        
+
         Ok(slotmap)
     }
 
@@ -201,7 +202,6 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
     }
 
     pub fn get_next_free_slot_handle(&self) -> K {
-
         let new_num_elems = self.num_elems + 1;
         if new_num_elems == core::u32::MAX {
             panic!("PillSlotMap number of elements overflow");
@@ -290,8 +290,11 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
         self.free_head = index as u32;
         self.num_elems -= 1;
 
-
-        slot.version = if slot.version >= self.version_limit { 0 } else { slot.version + 1 };
+        slot.version = if slot.version >= self.version_limit {
+            0
+        } else {
+            slot.version + 1
+        };
 
         value
     }
@@ -366,7 +369,7 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
             .value
     }
 
-    pub fn iter(&self) -> Iter<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         let mut it = self.slots.iter().enumerate();
         it.next(); // Skip sentinel.
         Iter {
@@ -376,7 +379,7 @@ impl<K: PillSlotMapKey, V> PillSlotMap<K, V> {
         }
     }
 
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
         let len = self.len();
         let mut it = self.slots.iter_mut().enumerate();
         it.next(); // Skip sentinel.
@@ -528,8 +531,18 @@ impl Default for PillSlotMapKeyData {
     }
 }
 
-pub unsafe trait PillSlotMapKey: 
-    From<PillSlotMapKeyData> + Copy + Clone + Default + Eq + PartialEq + Ord + PartialOrd + core::hash::Hash + core::fmt::Debug {
+pub unsafe trait PillSlotMapKey:
+    From<PillSlotMapKeyData>
+    + Copy
+    + Clone
+    + Default
+    + Eq
+    + PartialEq
+    + Ord
+    + PartialOrd
+    + core::hash::Hash
+    + core::fmt::Debug
+{
     fn null() -> Self {
         PillSlotMapKeyData::null().into()
     }