remove older stuff

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/function/from.rs

@@ -49,6 +49,7 @@ macro_rules! impl_from_with_downcast {
                         ScriptValue::Integer(i) => Ok(i as $ty),
                         ScriptValue::Float(i) => Ok(i as $ty),
                         ScriptValue::Reference(r) => r.downcast::<Self>(world),
+                        ScriptValue::Bool(b) => Ok(b as usize as $ty),
                         _ => Err(InteropError::value_mismatch(std::any::TypeId::of::<Self>(), value)),
                     }
                 }

crates/bevy_mod_scripting_core/src/bindings/function/into.rs

@@ -29,6 +29,12 @@ impl IntoScript for () {
     }
 }
 
+impl IntoScript for bool {
+    fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+        Ok(ScriptValue::Bool(self))
+    }
+}
+
 macro_rules! impl_into_with_downcast {
     ($variant:tt as $cast:ty [$($ty:ty),*]) => {
         $(
@@ -63,6 +69,7 @@ impl_into_stringlike!(
     s,
     [
         (String => s),
+        (char => s.to_string()),
         (PathBuf => s.to_string_lossy().to_string()),
         (OsString => s.into_string().map_err(|e| InteropError::unsupported_operation(None, Some(Box::new(e)), "Could not convert OsString to String".to_owned()))?)
     ]

crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs

@@ -0,0 +1,87 @@
+use std::{any::TypeId, ffi::OsString, path::PathBuf};
+
+use crate::{
+    bindings::{function::into::IntoScript, ReflectReference, WorldGuard},
+    error::InteropError,
+    prelude::ScriptValue,
+    reflection_extensions::TypeIdExtensions,
+};
+
+/// Converts a value represented by a reference into a [`crate::bindings::function::ScriptValue`].
+/// Instead of a direct conversion, the trait tries to peek into the value behind the reference and find out the most suitable representation.
+///
+/// - Primitives are converted to simple values
+/// - Container types are converted to references (so the references persist after accesses inside them)
+pub trait IntoScriptRef {
+    fn into_script_ref(
+        self_: ReflectReference,
+        world: WorldGuard,
+    ) -> Result<ScriptValue, InteropError>;
+}
+
+macro_rules! match_by_type {
+    (match $on:ident {$($id:ident : $ty:ty => $conv:expr),*}) => {
+        $(
+            let $id = std::any::TypeId::of::<$ty>();
+        )*
+
+        match $on {
+        $(
+            $id => {$conv},
+        )*
+            _ => {},
+        }
+    };
+}
+
+macro_rules! downcast_into_value {
+    ($r:ident, $ty:ty) => {
+        *$r.try_downcast_ref::<$ty>().ok_or_else(|| {
+            InteropError::type_mismatch(
+                std::any::TypeId::of::<$ty>(),
+                $r.get_represented_type_info().map(|i| i.type_id()),
+            )
+        })?
+    };
+}
+
+impl IntoScriptRef for ReflectReference {
+    fn into_script_ref(
+        self_: ReflectReference,
+        world: WorldGuard,
+    ) -> Result<ScriptValue, InteropError> {
+        self_.with_reflect(world.clone(), |r| {
+            let type_id = r
+                .get_represented_type_info()
+                .map(|i| i.type_id())
+                .or_fake_id();
+
+            match_by_type! (
+                match type_id {
+                    ta : usize   => return downcast_into_value!(r, usize).into_script(world),
+                    tb : isize   => return downcast_into_value!(r, isize).into_script(world),
+                    tc : u8      => return downcast_into_value!(r, u8).into_script(world),
+                    td : u16     => return downcast_into_value!(r, u16).into_script(world),
+                    te : u32     => return downcast_into_value!(r, u32).into_script(world),
+                    tf : u64     => return downcast_into_value!(r, u64).into_script(world),
+                    tg : u128    => return downcast_into_value!(r, u128).into_script(world),
+                    th : i8      => return downcast_into_value!(r, i8).into_script(world),
+                    ti : i16     => return downcast_into_value!(r, i16).into_script(world),
+                    tj : i32     => return downcast_into_value!(r, i32).into_script(world),
+                    tk : i64     => return downcast_into_value!(r, i64).into_script(world),
+                    tl : i128    => return downcast_into_value!(r, i128).into_script(world),
+                    tm : f32     => return downcast_into_value!(r, f32).into_script(world),
+                    tn : f64     => return downcast_into_value!(r, f64).into_script(world),
+                    to : bool    => return downcast_into_value!(r, bool).into_script(world),
+                    tp : char    => return downcast_into_value!(r, char).into_script(world),
+                    tq : String  => return downcast_into_value!(r, String).clone().into_script(world),
+                    tr : PathBuf => return downcast_into_value!(r, PathBuf).clone().into_script(world),
+                    ts : OsString=> return downcast_into_value!(r, OsString).clone().into_script(world),
+                    tn : ()      => return Ok(ScriptValue::Unit)
+                }
+            );
+
+            Ok(ScriptValue::Unit)
+        })?
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -2,6 +2,7 @@ use std::{any::TypeId, borrow::Cow, ops::Deref, sync::Arc};
 
 pub mod from;
 pub mod into;
+pub mod into_ref;
 pub mod script_function;
 
 use bevy::reflect::{
@@ -18,9 +19,7 @@ use crate::{
 };
 
 use super::{
-    access_map::ReflectAccessId,
-    pretty_print::DisplayWithWorld,
-    script_value::{FromScriptValue, IntoScriptValue, ScriptValue},
+    access_map::ReflectAccessId, pretty_print::DisplayWithWorld, script_value::ScriptValue,
     ReflectBase, ReflectReference, WorldAccessGuard, WorldCallbackAccess, WorldGuard,
 };
 

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -117,7 +117,7 @@ impl ReflectReferencePrinter {
         let type_id = v
             .get_represented_type_info()
             .map(|t| t.type_id())
-            .type_id_or_fake_id();
+            .or_fake_id();
 
         output.push_str("Reflect(");
         match type_id {