quill: Initial commit for ECS

Author: caelunshun

Cargo.lock

@@ -12,6 +12,7 @@ members = [
     # Quill
     "quill/sys-macros",
     "quill/sys",
+    "quill/ecs",
     "quill/common",
     "quill/api",
     "quill/plugin-format",

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "quill-ecs"
+version = "0.1.0"
+authors = ["caelunshun <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+bytemuck = "1"

quill/ecs/Cargo.toml

@@ -0,0 +1,67 @@
+use std::{alloc::Layout, any::TypeId, sync::Arc};
+
+use crate::space::MemorySpace;
+
+/// Type ID of a component.
+///
+/// Supports both Rust types and arbitrary
+/// "opaque" types identified by a `u64`.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct ComponentTypeId(ComponentTypeIdInner);
+
+impl ComponentTypeId {
+    pub fn of<T: 'static>() -> Self {
+        Self(ComponentTypeIdInner::Rust(TypeId::of::<T>()))
+    }
+
+    pub fn opaque(id: u64) -> Self {
+        Self(ComponentTypeIdInner::Opaque(id))
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+enum ComponentTypeIdInner {
+    Rust(TypeId),
+    Opaque(u64),
+}
+
+/// Metadata for a component type.
+#[derive(Clone)]
+pub struct ComponentMeta {
+    /// Memory space where the component is allocated.
+    pub(crate) space: Arc<MemorySpace>,
+    /// Component type ID.
+    pub(crate) type_id: ComponentTypeId,
+    /// Component layout.
+    pub(crate) layout: Layout,
+    /// Function to drop the component.
+    pub(crate) drop_fn: Arc<dyn Fn(*mut u8) + Send + Sync>,
+}
+
+impl ComponentMeta {
+    /// Creates a `ComponentMeta` for a native Rust component.
+    pub fn of<T: 'static>() -> Self {
+        Self {
+            space: Arc::new(MemorySpace::host()),
+            type_id: ComponentTypeId::of::<T>(),
+            layout: Layout::new::<T>(),
+            drop_fn: Arc::new(|data| unsafe { std::ptr::drop_in_place(data.cast::<T>()) }),
+        }
+    }
+
+    /// Creates a `ComponentMeta` for an arbitrary type, maybe opaque,
+    /// maybe allocated in a non-default memory space.
+    pub fn custom(
+        space: Arc<MemorySpace>,
+        type_id: ComponentTypeId,
+        layout: Layout,
+        drop_fn: Arc<dyn Fn(*mut u8) + Send + Sync>,
+    ) -> Self {
+        Self {
+            space,
+            type_id,
+            layout,
+            drop_fn,
+        }
+    }
+}

quill/ecs/src/component.rs

@@ -0,0 +1,25 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EntityId {
+    index: u32,
+    generation: u32,
+}
+
+impl EntityId {
+    pub fn to_bits(self) -> u64 {
+        ((self.index as u64) << 32) | (self.generation as u64)
+    }
+
+    pub fn from_bits(bits: u64) -> Self {
+        let index = (bits >> 32) as u32;
+        let generation = bits as u32;
+        Self { index, generation }
+    }
+
+    pub fn index(self) -> u32 {
+        self.index
+    }
+
+    pub fn generation(self) -> u32 {
+        self.generation
+    }
+}

quill/ecs/src/entity.rs

@@ -0,0 +1,56 @@
+use std::alloc::Layout;
+
+/// Provides extra methods on `Layout` that are unstable
+/// in `std`.
+pub trait LayoutExt: Sized {
+    fn repeat(&self, n: usize) -> Result<(Self, usize), ()>;
+
+    fn padding_needed_for(&self, align: usize) -> usize;
+}
+
+// Implementations taken from `std`.
+impl LayoutExt for Layout {
+    fn repeat(&self, n: usize) -> Result<(Self, usize), ()> {
+        // This cannot overflow. Quoting from the invariant of Layout:
+        // > `size`, when rounded up to the nearest multiple of `align`,
+        // > must not overflow (i.e., the rounded value must be less than
+        // > `usize::MAX`)
+        let padded_size = self.size() + <Self as LayoutExt>::padding_needed_for(self, self.align());
+        let alloc_size = padded_size.checked_mul(n).ok_or(())?;
+
+        // SAFETY: self.align is already known to be valid and alloc_size has been
+        // padded already.
+        unsafe {
+            Ok((
+                Layout::from_size_align_unchecked(alloc_size, self.align()),
+                padded_size,
+            ))
+        }
+    }
+
+    fn padding_needed_for(&self, align: usize) -> usize {
+        let len = self.size();
+
+        // Rounded up value is:
+        //   len_rounded_up = (len + align - 1) & !(align - 1);
+        // and then we return the padding difference: `len_rounded_up - len`.
+        //
+        // We use modular arithmetic throughout:
+        //
+        // 1. align is guaranteed to be > 0, so align - 1 is always
+        //    valid.
+        //
+        // 2. `len + align - 1` can overflow by at most `align - 1`,
+        //    so the &-mask with `!(align - 1)` will ensure that in the
+        //    case of overflow, `len_rounded_up` will itself be 0.
+        //    Thus the returned padding, when added to `len`, yields 0,
+        //    which trivially satisfies the alignment `align`.
+        //
+        // (Of course, attempts to allocate blocks of memory whose
+        // size and padding overflow in the above manner should cause
+        // the allocator to yield an error anyway.)
+
+        let len_rounded_up = len.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1);
+        len_rounded_up.wrapping_sub(len)
+    }
+}

quill/ecs/src/layout_ext.rs

@@ -0,0 +1,8 @@
+#![allow(unused)] // TEMP (remove before merge)
+#![allow(unstable_name_collisions)]
+
+mod layout_ext;
+mod space;
+mod storage;
+mod entity;
+mod component;

quill/ecs/src/lib.rs

@@ -0,0 +1,38 @@
+use std::alloc::Layout;
+
+/// A memory space used to store components.
+///
+/// The default memory space just allocates memory on the host.
+pub struct MemorySpace {
+    alloc: Box<dyn Fn(Layout) -> *mut u8 + Send + Sync>,
+    dealloc: Box<dyn Fn(*mut u8, Layout) + Send + Sync>,
+}
+
+impl MemorySpace {
+    pub fn host() -> Self {
+        unsafe {
+            Self::new(
+                |layout| std::alloc::alloc(layout),
+                |ptr, layout| std::alloc::dealloc(ptr, layout),
+            )
+        }
+    }
+
+    pub unsafe fn new(
+        alloc: impl Fn(Layout) -> *mut u8 + Send + Sync + 'static,
+        dealloc: impl Fn(*mut u8, Layout) + Send + Sync + 'static,
+    ) -> Self {
+        Self {
+            alloc: Box::new(alloc),
+            dealloc: Box::new(dealloc),
+        }
+    }
+
+    pub(crate) unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        (self.alloc)(layout)
+    }
+
+    pub(crate) unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        (self.dealloc)(ptr, layout)
+    }
+}

quill/ecs/src/space.rs

@@ -0,0 +1,2 @@
+mod blob_vec;
+mod sparse_set;