From 582128a649abc2f460ca00f45571deaf28dd526e Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Sat, 6 Jun 2026 20:00:52 +0200
Subject: chore(engine): re-export engine-reflection crate in reflection module

---
 engine/Cargo.toml        |   3 +-
 engine/src/reflection.rs | 205 +----------------------------------------------
 2 files changed, 3 insertions(+), 205 deletions(-)

(limited to 'engine')

diff --git a/engine/Cargo.toml b/engine/Cargo.toml
index 9803978..6bd7985 100644
--- a/engine/Cargo.toml
+++ b/engine/Cargo.toml
@@ -15,10 +15,11 @@ parking_lot = "0.12.3"
 safer-ffi = "0.1.13"
 nu-ansi-term = "0.46.0"
 crossbeam-queue = "0.3.12"
+engine-macros = { workspace = true }
 engine-ecs = { workspace = true }
+engine-reflection = { workspace = true }
 util-macros = { workspace = true }
 opengl-bindings = { workspace = true }
-engine-macros = { workspace = true }
 
 [dependencies.winit]
 version = "0.30.11"
diff --git a/engine/src/reflection.rs b/engine/src/reflection.rs
index 679c0b9..fd7e379 100644
--- a/engine/src/reflection.rs
+++ b/engine/src/reflection.rs
@@ -1,205 +1,2 @@
-use std::alloc::Layout;
-use std::any::{type_name, TypeId};
-use std::fmt::Debug;
-
 pub use engine_macros::Reflection;
-
-/// Trait implemented by types that support runtime reflection on them.
-///
-/// # Safety
-/// Implementors of this trait must provide accurate reflection information in the
-/// `TYPE_REFLECTION` associated constant and the `type_reflection` and
-/// `get_type_reflection` methods.
-pub unsafe trait Reflection: 'static
-{
-    const TYPE_REFLECTION: &Type;
-
-    fn type_reflection() -> &'static Type
-    where
-        Self: Sized,
-    {
-        Self::TYPE_REFLECTION
-    }
-
-    fn get_type_reflection(&self) -> &'static Type
-    {
-        Self::TYPE_REFLECTION
-    }
-}
-
-/// Trait implemented by enums that support runtime reflection on them.
-///
-/// # Safety
-/// Implementors of this trait must provide accurate reflection information in the
-/// `get_variant_reflection` method.
-pub unsafe trait EnumReflectionExt: Reflection
-{
-    fn get_variant_reflection(&self) -> &'static EnumVariant;
-}
-
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum Type
-{
-    Struct(Struct),
-    Enum(Enum),
-    Array(Array),
-    Slice(Slice),
-    Literal(Literal),
-}
-
-impl Type
-{
-    pub const fn as_struct(&self) -> Option<&Struct>
-    {
-        match self {
-            Self::Struct(struct_reflection) => Some(struct_reflection),
-            _ => None,
-        }
-    }
-
-    pub const fn as_enum(&self) -> Option<&Enum>
-    {
-        match self {
-            Self::Enum(enum_reflection) => Some(enum_reflection),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Struct
-{
-    pub fields: &'static [StructField],
-}
-
-#[derive(Debug, Clone)]
-pub struct StructField
-{
-    pub name: &'static str,
-    pub index: usize,
-    pub layout: Layout,
-    pub byte_offset: usize,
-    pub type_id: TypeId,
-    pub type_name: &'static str,
-    pub get_type: FnWithDebug<Option<&'static Type>>,
-}
-
-impl StructField
-{
-    pub fn type_reflection(&self) -> Option<&'static Type>
-    {
-        self.get_type.get()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Enum
-{
-    /// Enum variants in the same order as in the enum definition.
-    pub variants: &'static [EnumVariant],
-}
-
-#[derive(Debug, Clone)]
-pub struct EnumVariant
-{
-    pub name: &'static str,
-}
-
-#[derive(Debug, Clone)]
-pub struct Array
-{
-    pub item_reflection: &'static Type,
-    pub length: usize,
-}
-
-#[derive(Debug, Clone)]
-pub struct Slice
-{
-    pub item_reflection: &'static Type,
-}
-
-#[derive(Debug)]
-pub struct Literal
-{
-    pub layout: Layout,
-    pub type_id: TypeId,
-    pub type_name: fn() -> &'static str,
-}
-
-macro_rules! impl_with_for_literals {
-    ($($literal: ty),*) => {
-        $(
-            unsafe impl Reflection for $literal
-            {
-                const TYPE_REFLECTION: &Type = &Type::Literal(Literal {
-                    layout: Layout::new::<$literal>(),
-                    type_id: TypeId::of::<$literal>(),
-                    type_name: || type_name::<$literal>()
-                });
-            }
-        )*
-    };
-}
-
-impl_with_for_literals!(
-    u8,
-    i8,
-    u16,
-    i16,
-    u32,
-    i32,
-    u64,
-    i64,
-    u128,
-    i128,
-    f32,
-    f64,
-    usize,
-    isize,
-    &'static str
-);
-
-unsafe impl<T: Reflection, const LEN: usize> Reflection for [T; LEN]
-{
-    const TYPE_REFLECTION: &Type = &Type::Array(Array {
-        item_reflection: T::TYPE_REFLECTION,
-        length: LEN,
-    });
-}
-
-unsafe impl<T: Reflection> Reflection for &'static [T]
-{
-    const TYPE_REFLECTION: &Type =
-        &Type::Slice(Slice { item_reflection: T::TYPE_REFLECTION });
-}
-
-#[derive(Clone)]
-pub struct FnWithDebug<Value>
-{
-    func: fn() -> Value,
-}
-
-impl<Value> FnWithDebug<Value>
-{
-    pub const fn new(func: fn() -> Value) -> Self
-    {
-        Self { func }
-    }
-
-    pub fn get(&self) -> Value
-    {
-        (self.func)()
-    }
-}
-
-impl<Value: Debug> Debug for FnWithDebug<Value>
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        formatter
-            .debug_tuple("FnWithDebug")
-            .field(&self.get())
-            .finish()
-    }
-}
+pub use engine_reflection::*;
-- 
cgit v1.2.3-18-g5258